--- 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; }
@@ -107,17 +107,17 @@ public:
eParagraph,
ePage,
eDocument
};
/**
* Move the range or its points on specified amount of given units.
*/
- void Move(ETextUnit aUnit, int32_t aCount)
+ void std::move(ETextUnit aUnit, int32_t aCount)
{
MoveEnd(aUnit, aCount);
MoveStart(aUnit, aCount);
}
void MoveStart(ETextUnit aUnit, int32_t aCount)
{
MoveInternal(aUnit, aCount, *mStartContainer, mStartOffset,
mEndContainer, mEndOffset);
--- 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/accessible/xpcom/xpcAccessibleTextRange.h
+++ b/accessible/xpcom/xpcAccessibleTextRange.h
@@ -40,17 +40,17 @@ public:
NS_IMETHOD GetEmbeddedChildren(nsIArray** aList) final;
NS_IMETHOD Compare(nsIAccessibleTextRange* aOtherRange, bool* aResult) final;
NS_IMETHOD CompareEndPoints(uint32_t aEndPoint,
nsIAccessibleTextRange* aOtherRange,
uint32_t aOtherRangeEndPoint,
int32_t* aResult) final;
NS_IMETHOD GetText(nsAString& aText) final;
NS_IMETHOD GetBounds(nsIArray** aRectList) final;
- NS_IMETHOD Move(uint32_t aUnit, int32_t aCount) final;
+ NS_IMETHOD std::move(uint32_t aUnit, int32_t aCount) final;
NS_IMETHOD MoveStart(uint32_t aUnit, int32_t aCount) final;
NS_IMETHOD MoveEnd(uint32_t aUnit, int32_t aCount) final;
NS_IMETHOD Normalize(uint32_t aUnit) final;
NS_IMETHOD Crop(nsIAccessible* aContainer, bool* aSuccess) final;
NS_IMETHOD FindText(const nsAString& aText, bool aIsBackward, bool aIsIgnoreCase,
nsIAccessibleTextRange** aRange) final;
NS_IMETHOD FindAttr(uint32_t aAttr, nsIVariant* aVal, bool aIsBackward,
nsIAccessibleTextRange** aRange) final;
--- 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/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_ = ¤tEdge;
}
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,15 +174,15 @@ 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();
}
}
}
--- 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
@@ -977,17 +977,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
@@ -5687,25 +5687,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;
@@ -9513,17 +9513,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());
}
@@ -10470,17 +10470,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.
@@ -10540,17 +10540,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;
@@ -10666,23 +10666,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)
@@ -10690,17 +10690,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,
@@ -10871,17 +10871,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;
@@ -11167,17 +11167,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
@@ -7565,19 +7565,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
@@ -2422,17 +2422,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
@@ -2760,17 +2760,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) after the CDM has
// processed the request.
// If processing this operation results in the session actually closing,
--- a/dom/media/eme/MediaKeySession.cpp
+++ b/dom/media/eme/MediaKeySession.cpp
@@ -307,17 +307,17 @@ MediaKeySession::GenerateRequest(const n
// Let sanitized init data be a validated and sanitized version of init data.
// If sanitized init data is empty, reject promise with a NotSupportedError.
// Note: Remaining steps of generateRequest method continue in CDM.
// Convert initData to hex for easier logging.
- // Note: CreateSession() Move()s the data out of the array, so we have
+ // Note: CreateSession() std::move()s the data out of the array, so we have
// to copy it here.
nsAutoCString hexInitData(ToHexString(data));
PromiseId pid = mKeys->StorePromise(promise);
mKeys->ConnectPendingPromiseIdWithToken(pid, Token());
mKeys->GetCDMProxy()->CreateSession(Token(),
mSessionType,
pid,
aInitDataType, data);
@@ -436,17 +436,17 @@ MediaKeySession::Update(const ArrayBuffe
NS_LITERAL_CSTRING("Empty response buffer passed to MediaKeySession.update()"));
EME_LOG("MediaKeySession[%p,'%s'] Update() failed, empty response buffer",
this, NS_ConvertUTF16toUTF8(mSessionId).get());
return promise.forget();
}
// Convert response to hex for easier logging.
- // Note: UpdateSession() Move()s the data out of the array, so we have
+ // Note: UpdateSession() std::move()s the data out of the array, so we have
// to copy it here.
nsAutoCString hexResponse(ToHexString(data));
PromiseId pid = mKeys->StorePromise(promise);
mKeys->GetCDMProxy()->UpdateSession(mSessionId,
pid,
data);
--- a/dom/media/eme/MediaKeySystemAccess.cpp
+++ b/dom/media/eme/MediaKeySystemAccess.cpp
@@ -293,17 +293,17 @@ GetSupportedKeySystems()
clearkey.mMP4.SetCanDecrypt(EME_CODEC_AAC);
if (Preferences::GetBool("media.eme.vp9-in-mp4.enabled", false)) {
clearkey.mMP4.SetCanDecrypt(EME_CODEC_VP9);
}
clearkey.mWebM.SetCanDecrypt(EME_CODEC_VORBIS);
clearkey.mWebM.SetCanDecrypt(EME_CODEC_OPUS);
clearkey.mWebM.SetCanDecrypt(EME_CODEC_VP8);
clearkey.mWebM.SetCanDecrypt(EME_CODEC_VP9);
- keySystemConfigs.AppendElement(Move(clearkey));
+ keySystemConfigs.AppendElement(std::move(clearkey));
}
}
{
if (HavePluginForKeySystem(kEMEKeySystemWidevine)) {
KeySystemConfig widevine;
widevine.mKeySystem = NS_ConvertUTF8toUTF16(kEMEKeySystemWidevine);
widevine.mInitDataTypes.AppendElement(NS_LITERAL_STRING("cenc"));
widevine.mInitDataTypes.AppendElement(NS_LITERAL_STRING("keyids"));
@@ -367,29 +367,29 @@ GetSupportedKeySystems()
if (Preferences::GetBool("media.eme.vp9-in-mp4.enabled", false)) {
widevine.mMP4.SetCanDecryptAndDecode(EME_CODEC_VP9);
}
widevine.mWebM.SetCanDecrypt(EME_CODEC_VORBIS);
widevine.mWebM.SetCanDecrypt(EME_CODEC_OPUS);
widevine.mWebM.SetCanDecryptAndDecode(EME_CODEC_VP8);
widevine.mWebM.SetCanDecryptAndDecode(EME_CODEC_VP9);
#endif
- keySystemConfigs.AppendElement(Move(widevine));
+ keySystemConfigs.AppendElement(std::move(widevine));
}
}
return keySystemConfigs;
}
static bool
GetKeySystemConfig(const nsAString& aKeySystem, KeySystemConfig& aOutKeySystemConfig)
{
for (auto&& config : GetSupportedKeySystems()) {
if (config.mKeySystem.Equals(aKeySystem)) {
- aOutKeySystemConfig = mozilla::Move(config);
+ aOutKeySystemConfig = std::move(config);
return true;
}
}
// No matching key system found.
return false;
}
/* static */
@@ -759,17 +759,17 @@ GetSupportedCapabilities(
if (!supportedCapabilities.AppendElement(capabilities, mozilla::fallible)) {
NS_WARNING("GetSupportedCapabilities: Malloc failure");
return Sequence<MediaKeySystemMediaCapability>();
}
// Note: omitting steps 3.13.2, our robustness is not sophisticated enough
// to require considering all requirements together.
}
- return Move(supportedCapabilities);
+ return std::move(supportedCapabilities);
}
// "Get Supported Configuration and Consent" algorithm, steps 4-7 for
// distinctive identifier, and steps 8-11 for persistent state. The steps
// are the same for both requirements/features, so we factor them out into
// a single function.
static bool
CheckRequirement(const MediaKeysRequirement aRequirement,
@@ -950,17 +950,17 @@ GetSupportedConfig(const KeySystemConfig
// on session type is true, change accumulated configuration's
// persistentState value to "required".
if (config.mPersistentState == MediaKeysRequirement::Optional &&
IsPersistentSessionType(sessionType)) {
config.mPersistentState = MediaKeysRequirement::Required;
}
}
// Set the sessionTypes member of accumulated configuration to session types.
- config.mSessionTypes.Construct(Move(sessionTypes));
+ config.mSessionTypes.Construct(std::move(sessionTypes));
// If the videoCapabilities and audioCapabilities members in candidate
// configuration are both empty, return NotSupported.
if (aCandidate.mAudioCapabilities.IsEmpty() &&
aCandidate.mVideoCapabilities.IsEmpty()) {
// TODO: Most sites using EME still don't pass capabilities, so we
// can't reject on it yet without breaking them. So add this later.
// Log deprecation warning to encourage authors to not do this!
@@ -983,17 +983,17 @@ GetSupportedConfig(const KeySystemConfig
// If video capabilities is null, return NotSupported.
if (caps.IsEmpty()) {
EME_LOG("MediaKeySystemConfiguration (label='%s') rejected; "
"no supported video capabilities.",
NS_ConvertUTF16toUTF8(aCandidate.mLabel).get());
return false;
}
// Set the videoCapabilities member of accumulated configuration to video capabilities.
- config.mVideoCapabilities = Move(caps);
+ config.mVideoCapabilities = std::move(caps);
} else {
// Otherwise:
// Set the videoCapabilities member of accumulated configuration to an empty sequence.
}
// If the audioCapabilities member in candidate configuration is non-empty:
if (!aCandidate.mAudioCapabilities.IsEmpty()) {
// Let audio capabilities be the result of executing the Get Supported Capabilities
@@ -1009,17 +1009,17 @@ GetSupportedConfig(const KeySystemConfig
// If audio capabilities is null, return NotSupported.
if (caps.IsEmpty()) {
EME_LOG("MediaKeySystemConfiguration (label='%s') rejected; "
"no supported audio capabilities.",
NS_ConvertUTF16toUTF8(aCandidate.mLabel).get());
return false;
}
// Set the audioCapabilities member of accumulated configuration to audio capabilities.
- config.mAudioCapabilities = Move(caps);
+ config.mAudioCapabilities = std::move(caps);
} else {
// Otherwise:
// Set the audioCapabilities member of accumulated configuration to an empty sequence.
}
// If accumulated configuration's distinctiveIdentifier value is "optional", follow the
// steps for the first matching condition from the following list:
if (config.mDistinctiveIdentifier == MediaKeysRequirement::Optional) {
--- a/dom/media/eme/MediaKeySystemAccessManager.cpp
+++ b/dom/media/eme/MediaKeySystemAccessManager.cpp
@@ -319,17 +319,17 @@ MediaKeySystemAccessManager::Observe(nsI
nsAutoCString message;
MediaKeySystemStatus status =
MediaKeySystemAccess::GetKeySystemStatus(request.mKeySystem, message);
if (status == MediaKeySystemStatus::Cdm_not_installed) {
// Not yet installed, don't retry. Keep waiting until timeout.
continue;
}
// Status has changed, retry request.
- requests.AppendElement(Move(request));
+ requests.AppendElement(std::move(request));
mRequests.RemoveElementAt(i);
}
// Retry all pending requests, but this time fail if the CDM is not installed.
for (PendingRequest& request : requests) {
RetryRequest(request);
}
} else if (!strcmp(aTopic, "timer-callback")) {
// Find the timer that expired and re-run the request for it.
@@ -361,17 +361,17 @@ MediaKeySystemAccessManager::EnsureObser
mAddedObservers = NS_SUCCEEDED(obsService->AddObserver(this, "gmp-changed", false));
return mAddedObservers;
}
void
MediaKeySystemAccessManager::Shutdown()
{
EME_LOG("MediaKeySystemAccessManager::Shutdown");
- nsTArray<PendingRequest> requests(Move(mRequests));
+ nsTArray<PendingRequest> requests(std::move(mRequests));
for (PendingRequest& request : requests) {
// Cancel all requests; we're shutting down.
request.CancelTimer();
request.RejectPromise(NS_LITERAL_CSTRING("Promise still outstanding at MediaKeySystemAccessManager shutdown"));
}
if (mAddedObservers) {
nsCOMPtr<nsIObserverService> obsService = mozilla::services::GetObserverService();
if (obsService) {
--- a/dom/media/eme/mediadrm/MediaDrmCDMProxy.cpp
+++ b/dom/media/eme/mediadrm/MediaDrmCDMProxy.cpp
@@ -86,23 +86,23 @@ MediaDrmCDMProxy::CreateSession(uint32_t
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(mOwnerThread);
UniquePtr<CreateSessionData> data(new CreateSessionData());
data->mSessionType = aSessionType;
data->mCreateSessionToken = aCreateSessionToken;
data->mPromiseId = aPromiseId;
data->mInitDataType = NS_ConvertUTF16toUTF8(aInitDataType);
- data->mInitData = Move(aInitData);
+ data->mInitData = std::move(aInitData);
nsCOMPtr<nsIRunnable> task(
NewRunnableMethod<UniquePtr<CreateSessionData>&&>("MediaDrmCDMProxy::md_CreateSession",
this,
&MediaDrmCDMProxy::md_CreateSession,
- Move(data)));
+ std::move(data)));
mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL);
}
void
MediaDrmCDMProxy::LoadSession(PromiseId aPromiseId,
dom::MediaKeySessionType aSessionType,
const nsAString& aSessionId)
{
@@ -127,23 +127,23 @@ MediaDrmCDMProxy::UpdateSession(const ns
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(mOwnerThread);
NS_ENSURE_TRUE_VOID(!mKeys.IsNull());
UniquePtr<UpdateSessionData> data(new UpdateSessionData());
data->mPromiseId = aPromiseId;
data->mSessionId = NS_ConvertUTF16toUTF8(aSessionId);
- data->mResponse = Move(aResponse);
+ data->mResponse = std::move(aResponse);
nsCOMPtr<nsIRunnable> task(
NewRunnableMethod<UniquePtr<UpdateSessionData>&&>("MediaDrmCDMProxy::md_UpdateSession",
this,
&MediaDrmCDMProxy::md_UpdateSession,
- Move(data)));
+ std::move(data)));
mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL);
}
void
MediaDrmCDMProxy::CloseSession(const nsAString& aSessionId,
PromiseId aPromiseId)
{
MOZ_ASSERT(NS_IsMainThread());
@@ -153,17 +153,17 @@ MediaDrmCDMProxy::CloseSession(const nsA
UniquePtr<SessionOpData> data(new SessionOpData());
data->mPromiseId = aPromiseId;
data->mSessionId = NS_ConvertUTF16toUTF8(aSessionId);
nsCOMPtr<nsIRunnable> task(
NewRunnableMethod<UniquePtr<SessionOpData>&&>("MediaDrmCDMProxy::md_CloseSession",
this,
&MediaDrmCDMProxy::md_CloseSession,
- Move(data)));
+ std::move(data)));
mOwnerThread->Dispatch(task, NS_DISPATCH_NORMAL);
}
void
MediaDrmCDMProxy::RemoveSession(const nsAString& aSessionId,
PromiseId aPromiseId)
{
// TODO: Implement RemoveSession.
--- a/dom/media/eme/mediadrm/MediaDrmProxySupport.cpp
+++ b/dom/media/eme/mediadrm/MediaDrmProxySupport.cpp
@@ -158,17 +158,17 @@ MediaDrmJavaCallbacksSupport::OnSessionB
MOZ_ASSERT(NS_IsMainThread());
nsCString sessionId(reinterpret_cast<char*>(aSessionId->GetElements().Elements()),
aSessionId->Length());
nsTArray<jni::Object::LocalRef> keyInfosObjectArray(aKeyInfos->GetElements());
nsTArray<CDMKeyInfo> keyInfosArray;
for (auto&& keyInfoObject : keyInfosObjectArray) {
- java::SessionKeyInfo::LocalRef keyInfo(mozilla::Move(keyInfoObject));
+ java::SessionKeyInfo::LocalRef keyInfo(std::move(keyInfoObject));
mozilla::jni::ByteArray::LocalRef keyIdByteArray = keyInfo->KeyId();
nsTArray<int8_t> keyIdInt8Array = keyIdByteArray->GetElements();
// Cast nsTArray<int8_t> to nsTArray<uint8_t>
nsTArray<uint8_t>* keyId = reinterpret_cast<nsTArray<uint8_t>*>(&keyIdInt8Array);
auto keyStatus = keyInfo->Status(); // int32_t
keyInfosArray.AppendElement(CDMKeyInfo(*keyId,
dom::Optional<dom::MediaKeyStatus>(
MediaDrmKeyStatusToMediaKeyStatus(keyStatus)
--- a/dom/media/encoder/MediaEncoder.cpp
+++ b/dom/media/encoder/MediaEncoder.cpp
@@ -148,17 +148,17 @@ public:
AudioSegment copy;
copy.AppendSlice(audio, 0, audio.GetDuration());
nsresult rv =
mEncoderThread->Dispatch(
NewRunnableMethod<StoreCopyPassByRRef<AudioSegment>>(
"mozilla::AudioTrackEncoder::AppendAudioSegment",
- mEncoder, &AudioTrackEncoder::AppendAudioSegment, Move(copy)));
+ mEncoder, &AudioTrackEncoder::AppendAudioSegment, std::move(copy)));
MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));
Unused << rv;
}
void NotifyEnded() override
{
MOZ_ASSERT(mEncoder);
MOZ_ASSERT(mEncoderThread);
@@ -300,17 +300,17 @@ public:
VideoSegment copy;
copy.AppendSlice(aMedia, 0, aMedia.GetDuration());
nsresult rv =
mEncoderThread->Dispatch(
NewRunnableMethod<StoreCopyPassByRRef<VideoSegment>>(
"mozilla::VideoTrackEncoder::AppendVideoSegment",
- mEncoder, &VideoTrackEncoder::AppendVideoSegment, Move(copy)));
+ mEncoder, &VideoTrackEncoder::AppendVideoSegment, std::move(copy)));
MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));
Unused << rv;
}
void ClearFrames() override {}
void NotifyEnded() override
{
@@ -448,17 +448,17 @@ protected:
};
MediaEncoder::MediaEncoder(TaskQueue* aEncoderThread,
UniquePtr<ContainerWriter> aWriter,
AudioTrackEncoder* aAudioEncoder,
VideoTrackEncoder* aVideoEncoder,
const nsAString& aMIMEType)
: mEncoderThread(aEncoderThread)
- , mWriter(Move(aWriter))
+ , mWriter(std::move(aWriter))
, mAudioEncoder(aAudioEncoder)
, mVideoEncoder(aVideoEncoder)
, mEncoderListener(MakeAndAddRef<EncoderListener>(mEncoderThread, this))
, mStartTime(TimeStamp::Now())
, mMIMEType(aMIMEType)
, mInitialized(false)
, mMetadataEncoded(false)
, mCompleted(false)
@@ -730,17 +730,17 @@ MediaEncoder::CreateEncoder(TaskQueue* a
}
if (videoEncoder) {
videoEncoder->SetWorkerThread(aEncoderThread);
if (aVideoBitrate != 0) {
videoEncoder->SetBitrate(aVideoBitrate);
}
}
return MakeAndAddRef<MediaEncoder>(aEncoderThread,
- Move(writer),
+ std::move(writer),
audioEncoder,
videoEncoder,
mimeType);
}
nsresult
MediaEncoder::GetEncodedMetadata(nsTArray<nsTArray<uint8_t>>* aOutputBufs,
nsAString& aMIMEType)
--- a/dom/media/gmp/ChromiumCDMAdapter.cpp
+++ b/dom/media/gmp/ChromiumCDMAdapter.cpp
@@ -36,17 +36,17 @@ static void
InitializeHooks();
#endif
ChromiumCDMAdapter::ChromiumCDMAdapter(nsTArray<Pair<nsCString, nsCString>>&& aHostPathPairs)
{
#ifdef XP_WIN
InitializeHooks();
#endif
- PopulateHostFiles(Move(aHostPathPairs));
+ PopulateHostFiles(std::move(aHostPathPairs));
}
void
ChromiumCDMAdapter::SetAdaptee(PRLibrary* aLib)
{
mLib = aLib;
}
--- a/dom/media/gmp/ChromiumCDMAdapter.h
+++ b/dom/media/gmp/ChromiumCDMAdapter.h
@@ -37,24 +37,24 @@ public:
private:
const HostFileString mPath;
cdm::PlatformFile mFile = cdm::kInvalidPlatformFile;
};
struct HostFileData
{
HostFileData(HostFile&& aBinary, HostFile&& aSig)
- : mBinary(Move(aBinary))
- , mSig(Move(aSig))
+ : mBinary(std::move(aBinary))
+ , mSig(std::move(aSig))
{
}
HostFileData(HostFileData&& aOther)
- : mBinary(Move(aOther.mBinary))
- , mSig(Move(aOther.mSig))
+ : mBinary(std::move(aOther.mBinary))
+ , mSig(std::move(aOther.mSig))
{
}
~HostFileData() {}
HostFile mBinary;
HostFile mSig;
};
--- a/dom/media/gmp/ChromiumCDMCallbackProxy.cpp
+++ b/dom/media/gmp/ChromiumCDMCallbackProxy.cpp
@@ -85,17 +85,17 @@ void
ChromiumCDMCallbackProxy::SessionMessage(const nsACString& aSessionId,
uint32_t aMessageType,
nsTArray<uint8_t>&& aMessage)
{
DispatchToMainThread("ChromiumCDMProxy::OnSessionMessage",
&ChromiumCDMProxy::OnSessionMessage,
NS_ConvertUTF8toUTF16(aSessionId),
ToDOMMessageType(aMessageType),
- Move(aMessage));
+ std::move(aMessage));
}
static dom::MediaKeyStatus
ToDOMMediaKeyStatus(uint32_t aStatus)
{
switch (static_cast<cdm::KeyStatus>(aStatus)) {
case cdm::kUsable:
return dom::MediaKeyStatus::Usable;
--- a/dom/media/gmp/ChromiumCDMChild.cpp
+++ b/dom/media/gmp/ChromiumCDMChild.cpp
@@ -72,17 +72,17 @@ public:
~CDMShmemBuffer() override
{
GMP_LOG("CDMShmemBuffer(size=%" PRIu32 ") destructed writable=%d",
Size(),
mShmem.IsWritable());
if (mShmem.IsWritable()) {
// The shmem wasn't extracted to send its data back up to the parent process,
// so we can reuse the shmem.
- mProtocol->GiveBuffer(Move(mShmem));
+ mProtocol->GiveBuffer(std::move(mShmem));
}
}
void Destroy() override
{
GMP_LOG("CDMShmemBuffer::Destroy(size=%" PRIu32 ")", Size());
delete this;
}
@@ -1019,26 +1019,26 @@ ChromiumCDMChild::RecvDestroy()
return IPC_OK();
}
mozilla::ipc::IPCResult
ChromiumCDMChild::RecvGiveBuffer(ipc::Shmem&& aBuffer)
{
MOZ_ASSERT(IsOnMessageLoopThread());
- GiveBuffer(Move(aBuffer));
+ GiveBuffer(std::move(aBuffer));
return IPC_OK();
}
void
ChromiumCDMChild::GiveBuffer(ipc::Shmem&& aBuffer)
{
MOZ_ASSERT(IsOnMessageLoopThread());
size_t sz = aBuffer.Size<uint8_t>();
- mBuffers.AppendElement(Move(aBuffer));
+ mBuffers.AppendElement(std::move(aBuffer));
GMP_LOG("ChromiumCDMChild::RecvGiveBuffer(capacity=%zu"
") bufferSizes={%s} mDecoderInitialized=%d",
sz,
ToString(mBuffers).get(),
mDecoderInitialized);
}
} // namespace gmp
--- a/dom/media/gmp/ChromiumCDMParent.cpp
+++ b/dom/media/gmp/ChromiumCDMParent.cpp
@@ -454,31 +454,31 @@ ChromiumCDMParent::RecvOnSessionMessage(
{
GMP_LOG("ChromiumCDMParent::RecvOnSessionMessage(this=%p, sid=%s)",
this,
aSessionId.get());
if (!mCDMCallback || mIsShutdown) {
return IPC_OK();
}
- mCDMCallback->SessionMessage(aSessionId, aMessageType, Move(aMessage));
+ mCDMCallback->SessionMessage(aSessionId, aMessageType, std::move(aMessage));
return IPC_OK();
}
ipc::IPCResult
ChromiumCDMParent::RecvOnSessionKeysChange(
const nsCString& aSessionId,
nsTArray<CDMKeyInformation>&& aKeysInfo)
{
GMP_LOG("ChromiumCDMParent::RecvOnSessionKeysChange(this=%p)", this);
if (!mCDMCallback || mIsShutdown) {
return IPC_OK();
}
- mCDMCallback->SessionKeysChange(aSessionId, Move(aKeysInfo));
+ mCDMCallback->SessionKeysChange(aSessionId, std::move(aKeysInfo));
return IPC_OK();
}
ipc::IPCResult
ChromiumCDMParent::RecvOnExpirationChange(const nsCString& aSessionId,
const double& aSecondsSinceEpoch)
{
GMP_LOG("ChromiumCDMParent::RecvOnExpirationChange(this=%p) time=%lf",
@@ -728,17 +728,17 @@ ChromiumCDMParent::RecvDecodedData(const
if (!v) {
mDecodePromise.RejectIfExists(
MediaResult(NS_ERROR_OUT_OF_MEMORY,
RESULT_DETAIL("Can't create VideoData")),
__func__);
return IPC_OK();
}
- ReorderAndReturnOutput(Move(v));
+ ReorderAndReturnOutput(std::move(v));
return IPC_OK();
}
ipc::IPCResult
ChromiumCDMParent::RecvDecodedShmem(const CDMVideoFrame& aFrame,
ipc::Shmem&& aShmem)
{
@@ -776,34 +776,34 @@ ChromiumCDMParent::RecvDecodedShmem(cons
__func__);
return IPC_OK();
}
// Don't need to deallocate the shmem since the CDM process is responsible
// for it again.
autoDeallocateShmem.release();
- ReorderAndReturnOutput(Move(v));
+ ReorderAndReturnOutput(std::move(v));
return IPC_OK();
}
void
ChromiumCDMParent::ReorderAndReturnOutput(RefPtr<VideoData>&& aFrame)
{
if (mMaxRefFrames == 0) {
- mDecodePromise.ResolveIfExists({ Move(aFrame) }, __func__);
+ mDecodePromise.ResolveIfExists({ std::move(aFrame) }, __func__);
return;
}
- mReorderQueue.Push(Move(aFrame));
+ mReorderQueue.Push(std::move(aFrame));
MediaDataDecoder::DecodedData results;
while (mReorderQueue.Length() > mMaxRefFrames) {
results.AppendElement(mReorderQueue.Pop());
}
- mDecodePromise.Resolve(Move(results), __func__);
+ mDecodePromise.Resolve(std::move(results), __func__);
}
already_AddRefed<VideoData>
ChromiumCDMParent::CreateVideoFrame(const CDMVideoFrame& aFrame,
Span<uint8_t> aData)
{
VideoData::YCbCrBuffer b;
MOZ_ASSERT(aData.Length() > 0);
@@ -1073,20 +1073,20 @@ ChromiumCDMParent::RecvDrainComplete()
{
if (mIsShutdown) {
MOZ_ASSERT(mDecodePromise.IsEmpty());
return IPC_OK();
}
MediaDataDecoder::DecodedData samples;
while (!mReorderQueue.IsEmpty()) {
- samples.AppendElement(Move(mReorderQueue.Pop()));
+ samples.AppendElement(std::move(mReorderQueue.Pop()));
}
- mDecodePromise.ResolveIfExists(Move(samples), __func__);
+ mDecodePromise.ResolveIfExists(std::move(samples), __func__);
return IPC_OK();
}
RefPtr<ShutdownPromise>
ChromiumCDMParent::ShutdownVideoDecoder()
{
if (mIsShutdown || !mVideoDecoderInitialized) {
return ShutdownPromise::CreateAndResolve(true, __func__);
}
--- a/dom/media/gmp/ChromiumCDMProxy.cpp
+++ b/dom/media/gmp/ChromiumCDMProxy.cpp
@@ -228,17 +228,17 @@ ChromiumCDMProxy::CreateSession(uint32_t
nsTArray<uint8_t>>(
"gmp::ChromiumCDMParent::CreateSession",
cdm,
&gmp::ChromiumCDMParent::CreateSession,
aCreateSessionToken,
sessionType,
initDataType,
aPromiseId,
- Move(aInitData)));
+ std::move(aInitData)));
}
void
ChromiumCDMProxy::LoadSession(PromiseId aPromiseId,
dom::MediaKeySessionType aSessionType,
const nsAString& aSessionId)
{
MOZ_ASSERT(NS_IsMainThread());
@@ -277,17 +277,17 @@ ChromiumCDMProxy::SetServerCertificate(P
return;
}
mGMPThread->Dispatch(NewRunnableMethod<uint32_t, nsTArray<uint8_t>>(
"gmp::ChromiumCDMParent::SetServerCertificate",
cdm,
&gmp::ChromiumCDMParent::SetServerCertificate,
aPromiseId,
- Move(aCert)));
+ std::move(aCert)));
}
void
ChromiumCDMProxy::UpdateSession(const nsAString& aSessionId,
PromiseId aPromiseId,
nsTArray<uint8_t>& aResponse)
{
MOZ_ASSERT(NS_IsMainThread());
@@ -305,17 +305,17 @@ ChromiumCDMProxy::UpdateSession(const ns
}
mGMPThread->Dispatch(
NewRunnableMethod<nsCString, uint32_t, nsTArray<uint8_t>>(
"gmp::ChromiumCDMParent::UpdateSession",
cdm,
&gmp::ChromiumCDMParent::UpdateSession,
NS_ConvertUTF16toUTF8(aSessionId),
aPromiseId,
- Move(aResponse)));
+ std::move(aResponse)));
}
void
ChromiumCDMProxy::CloseSession(const nsAString& aSessionId,
PromiseId aPromiseId)
{
MOZ_ASSERT(NS_IsMainThread());
EME_LOG("ChromiumCDMProxy::CloseSession(sid='%s', pid=%u)",
--- a/dom/media/gmp/GMPChild.cpp
+++ b/dom/media/gmp/GMPChild.cpp
@@ -459,18 +459,18 @@ GMPChild::MakeCDMHostVerificationPaths()
sigFilePath = nsCString(NS_ConvertUTF16toUTF8(str) +
NS_LITERAL_CSTRING(".sig"));
}
#else
sigFilePath = nsCString(NS_ConvertUTF16toUTF8(str) +
NS_LITERAL_CSTRING(".sig"));
#endif
paths.AppendElement(
- MakePair(Move(filePath),
- Move(sigFilePath)));
+ MakePair(std::move(filePath),
+ std::move(sigFilePath)));
} else {
// Without successfully determining plugin-container's path, we can't
// determine libxul's or Firefox's. So give up.
return paths;
}
// Firefox application binary path.
nsCOMPtr<nsIFile> appDir;
@@ -489,18 +489,18 @@ GMPChild::MakeCDMHostVerificationPaths()
sigFilePath = NS_ConvertUTF16toUTF8(str);
} else {
// Cannot successfully get the sig file path.
// Assume it is located at the same place as firefox alternatively.
sigFilePath = nsCString(NS_ConvertUTF16toUTF8(str) +
NS_LITERAL_CSTRING(".sig"));
}
paths.AppendElement(
- MakePair(Move(filePath),
- Move(sigFilePath)));
+ MakePair(std::move(filePath),
+ std::move(sigFilePath)));
}
#else
// Note: re-using 'path' var here, as on Windows/Linux we assume Firefox
// executable is in the same directory as plugin-container.
if (NS_SUCCEEDED(path->GetParent(getter_AddRefs(appDir))) &&
NS_SUCCEEDED(appDir->Clone(getter_AddRefs(path))) &&
NS_SUCCEEDED(path->Append(FIREFOX_FILE)) && FileExists(path) &&
ResolveLinks(path) && NS_SUCCEEDED(path->GetPath(str))) {
@@ -528,18 +528,18 @@ GMPChild::MakeCDMHostVerificationPaths()
sigFilePath = nsCString(NS_ConvertUTF16toUTF8(str) +
NS_LITERAL_CSTRING(".sig"));
}
#else
sigFilePath = nsCString(NS_ConvertUTF16toUTF8(str) +
NS_LITERAL_CSTRING(".sig"));
#endif
paths.AppendElement(
- MakePair(Move(filePath),
- Move(sigFilePath)));
+ MakePair(std::move(filePath),
+ std::move(sigFilePath)));
}
return paths;
}
static nsCString
ToCString(const nsTArray<Pair<nsCString, nsCString>>& aPairs)
{
@@ -601,17 +601,17 @@ GMPChild::AnswerStartPlugin(const nsStri
pluginType).get());
}
#endif
GMPAdapter* adapter = nullptr;
if (isChromium) {
auto&& paths = MakeCDMHostVerificationPaths();
GMP_LOG("%s CDM host paths=%s", __func__, ToCString(paths).get());
- adapter = new ChromiumCDMAdapter(Move(paths));
+ adapter = new ChromiumCDMAdapter(std::move(paths));
}
if (!mGMPLoader->Load(libPath.get(),
libPath.Length(),
platformAPI,
adapter)) {
NS_WARNING("Failed to load GMP");
delete platformAPI;
--- a/dom/media/gmp/GMPParent.cpp
+++ b/dom/media/gmp/GMPParent.cpp
@@ -692,17 +692,17 @@ GMPParent::ReadGMPInfoFile(nsIFile* aFil
nsTArray<nsCString> tagTokens;
SplitAt(":", ts, tagTokens);
for (nsCString tag : tagTokens) {
cap.mAPITags.AppendElement(tag);
}
}
}
- mCapabilities.AppendElement(Move(cap));
+ mCapabilities.AppendElement(std::move(cap));
}
if (mCapabilities.IsEmpty()) {
return GenericPromise::CreateAndReject(NS_ERROR_FAILURE, __func__);
}
return GenericPromise::CreateAndResolve(true, __func__);
}
@@ -810,17 +810,17 @@ GMPParent::ParseChromiumManifest(const n
video.mAPITags.AppendElement(codec);
}
video.mAPITags.AppendElement(kEMEKeySystem);
video.mAPIName = NS_LITERAL_CSTRING(CHROMIUM_CDM_API);
mAdapter = NS_LITERAL_STRING("chromium");
- mCapabilities.AppendElement(Move(video));
+ mCapabilities.AppendElement(std::move(video));
return GenericPromise::CreateAndResolve(true, __func__);
}
bool
GMPParent::CanBeSharedCrossNodeIds() const
{
return mNodeId.IsEmpty() &&
@@ -888,17 +888,17 @@ GMPParent::OpenPGMPContent()
}
mGMPContentParent = new GMPContentParent(this);
if (!parent.Bind(mGMPContentParent)) {
return false;
}
- if (!SendInitGMPContentChild(Move(child))) {
+ if (!SendInitGMPContentChild(std::move(child))) {
return false;
}
ResolveGetContentParentPromises();
return true;
}
@@ -918,17 +918,17 @@ GMPParent::GetGMPContentParent(UniquePtr
{
LOGD("%s %p", __FUNCTION__, this);
MOZ_ASSERT(GMPEventTarget()->IsOnCurrentThread());
if (mGMPContentParent) {
RefPtr<GMPContentParent::CloseBlocker> blocker(new GMPContentParent::CloseBlocker(mGMPContentParent));
aPromiseHolder->Resolve(blocker, __func__);
} else {
- mGetContentParentPromises.AppendElement(Move(aPromiseHolder));
+ mGetContentParentPromises.AppendElement(std::move(aPromiseHolder));
// If we don't have a GMPContentParent and we try to get one for the first
// time (mGetContentParentPromises.Length() == 1) then call PGMPContent::Open. If more
// calls to GetGMPContentParent happen before mGMPContentParent has been
// set then we should just store them, so that they get called when we set
// mGMPContentParent as a result of the PGMPContent::Open call.
if (mGetContentParentPromises.Length() == 1) {
if (!EnsureProcessLoaded() || !OpenPGMPContent()) {
RejectGetContentParentPromises();
@@ -941,17 +941,17 @@ GMPParent::GetGMPContentParent(UniquePtr
}
}
}
already_AddRefed<GMPContentParent>
GMPParent::ForgetGMPContentParent()
{
MOZ_ASSERT(mGetContentParentPromises.IsEmpty());
- return Move(mGMPContentParent.forget());
+ return std::move(mGMPContentParent.forget());
}
bool
GMPParent::EnsureProcessLoaded(base::ProcessId* aID)
{
if (!EnsureProcessLoaded()) {
return false;
}
--- a/dom/media/gmp/GMPParent.h
+++ b/dom/media/gmp/GMPParent.h
@@ -27,18 +27,18 @@ class CrashReporterHost;
} // namespace ipc
namespace gmp {
class GMPCapability
{
public:
explicit GMPCapability() {}
GMPCapability(GMPCapability&& aOther)
- : mAPIName(Move(aOther.mAPIName))
- , mAPITags(Move(aOther.mAPITags))
+ : mAPIName(std::move(aOther.mAPIName))
+ , mAPITags(std::move(aOther.mAPITags))
{
}
explicit GMPCapability(const nsCString& aAPIName)
: mAPIName(aAPIName)
{}
explicit GMPCapability(const GMPCapability& aOther) = default;
nsCString mAPIName;
nsTArray<nsCString> mAPITags;
--- a/dom/media/gmp/GMPPlatform.cpp
+++ b/dom/media/gmp/GMPPlatform.cpp
@@ -323,30 +323,30 @@ GMPMutexImpl::Release()
GMPTask*
NewGMPTask(std::function<void()>&& aFunction)
{
class Task : public GMPTask
{
public:
explicit Task(std::function<void()>&& aFunction)
- : mFunction(Move(aFunction))
+ : mFunction(std::move(aFunction))
{
}
void Destroy() override
{
delete this;
}
~Task() override
{
}
void Run() override
{
mFunction();
}
private:
std::function<void()> mFunction;
};
- return new Task(Move(aFunction));
+ return new Task(std::move(aFunction));
}
} // namespace gmp
} // namespace mozilla
--- a/dom/media/gmp/GMPService.h
+++ b/dom/media/gmp/GMPService.h
@@ -92,17 +92,17 @@ public:
// Helper for backwards compatibility with WebRTC/tests.
NS_IMETHOD
GetGMPVideoDecoder(GMPCrashHelper* aHelper,
nsTArray<nsCString>* aTags,
const nsACString& aNodeId,
UniquePtr<GetGMPVideoDecoderCallback>&& aCallback) override
{
- return GetDecryptingGMPVideoDecoder(aHelper, aTags, aNodeId, Move(aCallback), 0);
+ return GetDecryptingGMPVideoDecoder(aHelper, aTags, aNodeId, std::move(aCallback), 0);
}
NS_IMETHOD RunPluginCrashCallbacks(uint32_t aPluginId,
const nsACString& aPluginName) override;
RefPtr<AbstractThread> GetAbstractGMPThread();
void ConnectCrashHelper(uint32_t aPluginId, GMPCrashHelper* aHelper);
--- a/dom/media/gmp/GMPServiceChild.cpp
+++ b/dom/media/gmp/GMPServiceChild.cpp
@@ -113,17 +113,17 @@ GeckoMediaPluginServiceChild::GetContent
errorDescription.get()));
LOGD(("%s", error.Description().get()));
holder->Reject(error, __func__);
return;
}
RefPtr<GMPContentParent> parent =
- child->GetBridgedGMPContentParent(otherProcess, Move(endpoint));
+ child->GetBridgedGMPContentParent(otherProcess, std::move(endpoint));
if (!alreadyBridgedTo.Contains(otherProcess)) {
parent->SetDisplayName(displayName);
parent->SetPluginId(pluginId);
}
RefPtr<GMPContentParent::CloseBlocker> blocker(
new GMPContentParent::CloseBlocker(parent));
holder->Resolve(blocker, __func__);
},
@@ -197,17 +197,17 @@ GeckoMediaPluginServiceChild::GetContent
errorDescription.get()));
LOGD(("%s", error.Description().get()));
holder->Reject(error, __func__);
return;
}
RefPtr<GMPContentParent> parent = child->GetBridgedGMPContentParent(otherProcess,
- Move(endpoint));
+ std::move(endpoint));
if (!alreadyBridgedTo.Contains(otherProcess)) {
parent->SetDisplayName(displayName);
parent->SetPluginId(pluginId);
}
RefPtr<GMPContentParent::CloseBlocker> blocker(new GMPContentParent::CloseBlocker(parent));
holder->Resolve(blocker, __func__);
},
@@ -229,17 +229,17 @@ struct GMPCapabilityAndVersion
, mVersion(aCapabilities.version())
{
for (const GMPAPITags& tags : aCapabilities.capabilities()) {
GMPCapability cap;
cap.mAPIName = tags.api();
for (const nsCString& tag : tags.tags()) {
cap.mAPITags.AppendElement(tag);
}
- mCapabilities.AppendElement(Move(cap));
+ mCapabilities.AppendElement(std::move(cap));
}
}
nsCString ToString() const
{
nsCString s;
s.Append(mName);
s.AppendLiteral(" version=");
@@ -423,17 +423,17 @@ GeckoMediaPluginServiceChild::GetService
return GetServiceChildPromise::CreateAndResolve(mServiceChild.get(), __func__);
}
void
GeckoMediaPluginServiceChild::SetServiceChild(UniquePtr<GMPServiceChild>&& aServiceChild)
{
MOZ_ASSERT(mGMPThread->EventTarget()->IsOnCurrentThread());
- mServiceChild = Move(aServiceChild);
+ mServiceChild = std::move(aServiceChild);
nsTArray<MozPromiseHolder<GetServiceChildPromise>> holders;
holders.SwapElements(mGetServiceChildPromises);
for (MozPromiseHolder<GetServiceChildPromise>& holder : holders) {
holder.Resolve(mServiceChild.get(), __func__);
}
}
@@ -505,28 +505,28 @@ GMPServiceChild::GetAlreadyBridgedTo(nsT
}
class OpenPGMPServiceChild : public mozilla::Runnable
{
public:
OpenPGMPServiceChild(UniquePtr<GMPServiceChild>&& aGMPServiceChild,
ipc::Endpoint<PGMPServiceChild>&& aEndpoint)
: Runnable("gmp::OpenPGMPServiceChild")
- , mGMPServiceChild(Move(aGMPServiceChild))
- , mEndpoint(Move(aEndpoint))
+ , mGMPServiceChild(std::move(aGMPServiceChild))
+ , mEndpoint(std::move(aEndpoint))
{
}
NS_IMETHOD Run() override
{
RefPtr<GeckoMediaPluginServiceChild> gmp =
GeckoMediaPluginServiceChild::GetSingleton();
MOZ_ASSERT(!gmp->mServiceChild);
if (mEndpoint.Bind(mGMPServiceChild.get())) {
- gmp->SetServiceChild(Move(mGMPServiceChild));
+ gmp->SetServiceChild(std::move(mGMPServiceChild));
} else {
gmp->SetServiceChild(nullptr);
}
return NS_OK;
}
private:
UniquePtr<GMPServiceChild> mGMPServiceChild;
@@ -542,18 +542,18 @@ GMPServiceChild::Create(Endpoint<PGMPSer
MOZ_ASSERT(!gmp->mServiceChild);
UniquePtr<GMPServiceChild> serviceChild(new GMPServiceChild());
nsCOMPtr<nsIThread> gmpThread;
nsresult rv = gmp->GetThread(getter_AddRefs(gmpThread));
NS_ENSURE_SUCCESS(rv, false);
- rv = gmpThread->Dispatch(new OpenPGMPServiceChild(Move(serviceChild),
- Move(aGMPService)),
+ rv = gmpThread->Dispatch(new OpenPGMPServiceChild(std::move(serviceChild),
+ std::move(aGMPService)),
NS_DISPATCH_NORMAL);
return NS_SUCCEEDED(rv);
}
ipc::IPCResult
GMPServiceChild::RecvBeginShutdown()
{
RefPtr<GeckoMediaPluginServiceChild> service =
--- a/dom/media/gmp/GMPServiceParent.cpp
+++ b/dom/media/gmp/GMPServiceParent.cpp
@@ -369,17 +369,17 @@ GeckoMediaPluginServiceParent::GetConten
auto holder = MakeUnique<MozPromiseHolder<GetGMPContentParentPromise>>();
RefPtr<GetGMPContentParentPromise> promise = holder->Ensure(__func__);
EnsureInitialized()->Then(thread, __func__, [
self = RefPtr<GeckoMediaPluginServiceParent>(this),
nodeIdString = nsCString(aNodeIdString),
api = nsCString(aAPI),
tags = nsTArray<nsCString>(aTags),
helper = RefPtr<GMPCrashHelper>(aHelper),
- holder = Move(holder)
+ holder = std::move(holder)
](const GenericPromise::ResolveOrRejectValue& aValue) mutable -> void {
if (aValue.IsReject()) {
NS_WARNING("GMPService::EnsureInitialized failed.");
holder->Reject(NS_ERROR_FAILURE, __func__);
return;
}
RefPtr<GMPParent> gmp = self->SelectPluginForAPI(nodeIdString, api, tags);
LOGD(("%s: %p returning %p for api %s",
@@ -388,17 +388,17 @@ GeckoMediaPluginServiceParent::GetConten
gmp.get(),
api.get()));
if (!gmp) {
NS_WARNING("GeckoMediaPluginServiceParent::GetContentParentFrom failed");
holder->Reject(NS_ERROR_FAILURE, __func__);
return;
}
self->ConnectCrashHelper(gmp->GetPluginId(), helper);
- gmp->GetGMPContentParent(Move(holder));
+ gmp->GetGMPContentParent(std::move(holder));
});
return promise;
}
RefPtr<GetGMPContentParentPromise>
GeckoMediaPluginServiceParent::GetContentParent(
GMPCrashHelper* aHelper,
@@ -615,17 +615,17 @@ GeckoMediaPluginServiceParent::UpdateCon
continue;
}
GMPCapabilityData x;
x.name() = name;
x.version() = gmp->GetVersion();
for (const GMPCapability& tag : gmp->GetCapabilities()) {
x.capabilities().AppendElement(GMPAPITags(tag.mAPIName, tag.mAPITags));
}
- caps.AppendElement(Move(x));
+ caps.AppendElement(std::move(x));
}
}
for (auto* cp : ContentParent::AllProcesses(ContentParent::eLive)) {
Unused << cp->SendGMPsChanged(caps);
}
// For non-e10s, we must fire a notification so that any MediaKeySystemAccess
// requests waiting on a CDM to download will retry.
@@ -1774,19 +1774,19 @@ GMPServiceParent::RecvLaunchGMP(const ns
PGMPContent::CreateEndpoints(OtherPid(), *aOutProcessId, &parent, &child);
if (NS_WARN_IF(NS_FAILED(rv))) {
*aOutRv = rv;
*aOutErrorDescription =
NS_LITERAL_CSTRING("PGMPContent::CreateEndpoints failed.");
return IPC_OK();
}
- *aOutEndpoint = Move(parent);
+ *aOutEndpoint = std::move(parent);
- if (!gmp->SendInitGMPContentChild(Move(child))) {
+ if (!gmp->SendInitGMPContentChild(std::move(child))) {
*aOutRv = NS_ERROR_FAILURE;
*aOutErrorDescription =
NS_LITERAL_CSTRING("SendInitGMPContentChild failed.");
return IPC_OK();
}
gmp->IncrementGMPContentChildCount();
@@ -1812,18 +1812,18 @@ GMPServiceParent::RecvLaunchGMPForNodeId
aNodeId.mOrigin(), aNodeId.mTopLevelOrigin(), aNodeId.mGMPName(), nodeId);
if (!NS_SUCCEEDED(rv)) {
*aOutRv = rv;
*aOutErrorDescription = NS_LITERAL_CSTRING("GetNodeId failed.");
return IPC_OK();
}
return RecvLaunchGMP(nodeId,
aApi,
- Move(aTags),
- Move(aAlreadyBridgedTo),
+ std::move(aTags),
+ std::move(aAlreadyBridgedTo),
aOutPluginId,
aOutId,
aOutDisplayName,
aOutEndpoint,
aOutRv,
aOutErrorDescription);
}
@@ -1880,17 +1880,17 @@ GMPServiceParent::ActorDestroy(ActorDest
// Make sure the IPC channel is closed before destroying mToDelete.
MonitorAutoLock lock(monitor);
RefPtr<Runnable> task = NewNonOwningRunnableMethod<Monitor*, bool*>(
"gmp::GMPServiceParent::CloseTransport",
this,
&GMPServiceParent::CloseTransport,
&monitor,
&completed);
- XRE_GetIOMessageLoop()->PostTask(Move(task.forget()));
+ XRE_GetIOMessageLoop()->PostTask(std::move(task.forget()));
while (!completed) {
lock.Wait();
}
// Dispatch a task to the current thread to ensure we don't delete the
// GMPServiceParent until the current calling context is finished with
// the object.
@@ -1908,17 +1908,17 @@ GMPServiceParent::ActorDestroy(ActorDest
class OpenPGMPServiceParent : public mozilla::Runnable
{
public:
OpenPGMPServiceParent(GMPServiceParent* aGMPServiceParent,
ipc::Endpoint<PGMPServiceParent>&& aEndpoint,
bool* aResult)
: Runnable("gmp::OpenPGMPServiceParent")
, mGMPServiceParent(aGMPServiceParent)
- , mEndpoint(Move(aEndpoint))
+ , mEndpoint(std::move(aEndpoint))
, mResult(aResult)
{
}
NS_IMETHOD Run() override
{
*mResult = mEndpoint.Bind(mGMPServiceParent);
return NS_OK;
@@ -1944,17 +1944,17 @@ GMPServiceParent::Create(Endpoint<PGMPSe
nsCOMPtr<nsIThread> gmpThread;
nsresult rv = gmp->GetThread(getter_AddRefs(gmpThread));
NS_ENSURE_SUCCESS(rv, false);
nsAutoPtr<GMPServiceParent> serviceParent(new GMPServiceParent(gmp));
bool ok;
rv = gmpThread->Dispatch(new OpenPGMPServiceParent(serviceParent,
- Move(aGMPService),
+ std::move(aGMPService),
&ok),
NS_DISPATCH_SYNC);
if (NS_WARN_IF(NS_FAILED(rv) || !ok)) {
return false;
}
// Now that the service parent is set up, it will be destroyed by
--- a/dom/media/gmp/GMPStorageChild.cpp
+++ b/dom/media/gmp/GMPStorageChild.cpp
@@ -21,17 +21,17 @@
} \
} while(false)
static nsTArray<uint8_t>
ToArray(const uint8_t* aData, uint32_t aDataSize)
{
nsTArray<uint8_t> data;
data.AppendElements(aData, aDataSize);
- return mozilla::Move(data);
+ return std::move(data);
}
namespace mozilla {
namespace gmp {
GMPRecordImpl::GMPRecordImpl(GMPStorageChild* aOwner,
const nsCString& aName,
GMPRecordClient* aClient)
--- a/dom/media/gtest/TestAudioTrackEncoder.cpp
+++ b/dom/media/gtest/TestAudioTrackEncoder.cpp
@@ -227,17 +227,17 @@ TEST(OpusAudioTrackEncoder, FrameEncode)
// Generate five seconds of raw audio data.
AudioGenerator generator(channels, sampleRate);
AudioSegment segment;
const int32_t samples = sampleRate * 5;
generator.Generate(segment, samples);
encoder.SetStartOffset(0);
- encoder.AppendAudioSegment(Move(segment));
+ encoder.AppendAudioSegment(std::move(segment));
encoder.AdvanceCurrentTime(samples);
EncodedFrameContainer container;
EXPECT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
// Verify that encoded data is 5 seconds long.
uint64_t totalDuration = 0;
for (auto& frame : container.GetEncodedFrames()) {
--- a/dom/media/gtest/TestCDMStorage.cpp
+++ b/dom/media/gtest/TestCDMStorage.cpp
@@ -211,17 +211,17 @@ private:
NS_IMPL_ISUPPORTS(ClearCDMStorageTask, nsIRunnable, nsIObserver)
static void
ClearCDMStorage(already_AddRefed<nsIRunnable> aContinuation,
nsIThread* aTarget, PRTime aSince = -1)
{
RefPtr<ClearCDMStorageTask> task(
- new ClearCDMStorageTask(Move(aContinuation), aTarget, aSince));
+ new ClearCDMStorageTask(std::move(aContinuation), aTarget, aSince));
SystemGroup::Dispatch(TaskCategory::Other, task.forget());
}
static void
SimulatePBModeExit()
{
// SystemGroup::EventTargetFor() doesn't support NS_DISPATCH_SYNC.
NS_DispatchToMainThread(new NotifyObserversTask("last-pb-context-exited"), NS_DISPATCH_SYNC);
@@ -296,17 +296,17 @@ GetNodeId(const nsAString& aOrigin,
topLevelOrigin.Assign(aTopLevelOrigin);
topLevelOrigin.Append(NS_ConvertUTF8toUTF16(suffix));
// We rely on the fact that the GetNodeId implementation for
// GeckoMediaPluginServiceParent is synchronous.
nsresult rv = service->GetNodeId(origin,
topLevelOrigin,
NS_LITERAL_STRING("gmp-fake"),
- Move(callback));
+ std::move(callback));
EXPECT_TRUE(NS_SUCCEEDED(rv) && NS_SUCCEEDED(result));
return nodeId;
}
static bool
IsCDMStorageIsEmpty()
{
RefPtr<GeckoMediaPluginServiceParent> service =
@@ -420,38 +420,38 @@ class CDMStorageTest
void CreateDecryptor(const nsAString& aOrigin,
const nsAString& aTopLevelOrigin,
bool aInPBMode,
const nsCString& aUpdate)
{
nsTArray<nsCString> updates;
updates.AppendElement(aUpdate);
- CreateDecryptor(aOrigin, aTopLevelOrigin, aInPBMode, Move(updates));
+ CreateDecryptor(aOrigin, aTopLevelOrigin, aInPBMode, std::move(updates));
}
void CreateDecryptor(const nsAString& aOrigin,
const nsAString& aTopLevelOrigin,
bool aInPBMode,
nsTArray<nsCString>&& aUpdates) {
- CreateDecryptor(GetNodeId(aOrigin, aTopLevelOrigin, NS_LITERAL_STRING("gmp-fake"), aInPBMode), Move(aUpdates));
+ CreateDecryptor(GetNodeId(aOrigin, aTopLevelOrigin, NS_LITERAL_STRING("gmp-fake"), aInPBMode), std::move(aUpdates));
}
void CreateDecryptor(const NodeId& aNodeId,
nsTArray<nsCString>&& aUpdates) {
RefPtr<GeckoMediaPluginService> service =
GeckoMediaPluginService::GetGeckoMediaPluginService();
EXPECT_TRUE(service);
nsTArray<nsCString> tags;
tags.AppendElement(NS_LITERAL_CSTRING("fake"));
RefPtr<CDMStorageTest> self = this;
RefPtr<gmp::GetCDMParentPromise> promise =
- service->GetCDM(aNodeId, Move(tags), nullptr);
+ service->GetCDM(aNodeId, std::move(tags), nullptr);
auto thread = GetAbstractGMPThread();
promise->Then(thread,
__func__,
[self, aUpdates](RefPtr<gmp::ChromiumCDMParent> cdm) {
self->mCDM = cdm;
EXPECT_TRUE(!!self->mCDM);
self->mCallback.reset(new CallbackProxy(self));
nsCString failureReason;
@@ -564,33 +564,33 @@ class CDMStorageTest
EnumerateCDMStorageDir(NS_LITERAL_CSTRING("id"),
NodeIdCollector(siteInfo.get()));
// Invoke "Forget this site" on the main thread.
SystemGroup::Dispatch(TaskCategory::Other,
NewRunnableMethod<UniquePtr<NodeInfo>&&>(
"CDMStorageTest::TestForgetThisSite_Forget",
this,
&CDMStorageTest::TestForgetThisSite_Forget,
- Move(siteInfo)));
+ std::move(siteInfo)));
}
void TestForgetThisSite_Forget(UniquePtr<NodeInfo>&& aSiteInfo) {
RefPtr<GeckoMediaPluginServiceParent> service =
GeckoMediaPluginServiceParent::GetSingleton();
service->ForgetThisSiteNative(NS_ConvertUTF8toUTF16(aSiteInfo->siteToForget),
aSiteInfo->mPattern);
nsCOMPtr<nsIThread> thread;
service->GetThread(getter_AddRefs(thread));
nsCOMPtr<nsIRunnable> r = NewRunnableMethod<UniquePtr<NodeInfo>&&>(
"CDMStorageTest::TestForgetThisSite_Verify",
this,
&CDMStorageTest::TestForgetThisSite_Verify,
- Move(aSiteInfo));
+ std::move(aSiteInfo));
thread->Dispatch(r, NS_DISPATCH_NORMAL);
nsCOMPtr<nsIRunnable> f = NewRunnableMethod(
"CDMStorageTest::SetFinished", this, &CDMStorageTest::SetFinished);
thread->Dispatch(f, NS_DISPATCH_NORMAL);
}
class NodeIdVerifier {
@@ -959,34 +959,34 @@ class CDMStorageTest
update.Append(data);
CreateDecryptor(NS_LITERAL_STRING("http://fuz.com"),
NS_LITERAL_STRING("http://baz.com"),
false,
update);
}
void Expect(const nsCString& aMessage, already_AddRefed<nsIRunnable> aContinuation) {
- mExpected.AppendElement(ExpectedMessage(aMessage, Move(aContinuation)));
+ mExpected.AppendElement(ExpectedMessage(aMessage, std::move(aContinuation)));
}
void AwaitFinished() {
mozilla::SpinEventLoopUntil([&]() -> bool { return mFinished; });
mFinished = false;
}
void ShutdownThen(already_AddRefed<nsIRunnable> aContinuation) {
EXPECT_TRUE(!!mCDM);
if (!mCDM) {
return;
}
EXPECT_FALSE(mNodeId.IsEmpty());
RefPtr<GMPShutdownObserver> task(new GMPShutdownObserver(
NewRunnableMethod(
"CDMStorageTest::Shutdown", this, &CDMStorageTest::Shutdown),
- Move(aContinuation),
+ std::move(aContinuation),
mNodeId));
SystemGroup::Dispatch(TaskCategory::Other, task.forget());
}
void Shutdown() {
if (mCDM) {
mCDM->Shutdown();
mCDM = nullptr;
@@ -1074,17 +1074,17 @@ private:
void RejectPromise(uint32_t aPromiseId,
nsresult aError,
const nsCString& aErrorMessage) override { }
void SessionMessage(const nsACString& aSessionId,
uint32_t aMessageType,
nsTArray<uint8_t>&& aMessage) override
{
- mRunner->SessionMessage(aSessionId, aMessageType, Move(aMessage));
+ mRunner->SessionMessage(aSessionId, aMessageType, std::move(aMessage));
}
void SessionKeysChange(const nsCString& aSessionId,
nsTArray<mozilla::gmp::CDMKeyInformation>&& aKeysInfo) override { }
void ExpirationChange(const nsCString& aSessionId,
double aSecondsSinceEpoch) override { }
--- a/dom/media/gtest/TestGMPCrossOrigin.cpp
+++ b/dom/media/gtest/TestGMPCrossOrigin.cpp
@@ -56,17 +56,17 @@ public:
aGMP->Close();
}
mMonitor.SetFinished();
}
static void Run(GMPTestMonitor& aMonitor, const nsCString& aOrigin)
{
UniquePtr<GMPCallbackType> callback(new RunTestGMPVideoCodec(aMonitor));
- Get(aOrigin, Move(callback));
+ Get(aOrigin, std::move(callback));
}
protected:
typedef T GMPCodecType;
typedef Base GMPCallbackType;
explicit RunTestGMPVideoCodec(GMPTestMonitor& aMonitor)
: mMonitor(aMonitor)
@@ -76,17 +76,17 @@ protected:
static nsresult Get(const nsACString& aNodeId, UniquePtr<Base>&& aCallback)
{
nsTArray<nsCString> tags;
tags.AppendElement(NS_LITERAL_CSTRING("h264"));
tags.AppendElement(NS_LITERAL_CSTRING("fake"));
RefPtr<GeckoMediaPluginService> service =
GeckoMediaPluginService::GetGeckoMediaPluginService();
- return ((*service).*Getter)(nullptr, &tags, aNodeId, Move(aCallback));
+ return ((*service).*Getter)(nullptr, &tags, aNodeId, std::move(aCallback));
}
protected:
GMPTestMonitor& mMonitor;
};
typedef RunTestGMPVideoCodec<GMPVideoDecoderProxy,
GetGMPVideoDecoderCallback,
@@ -120,29 +120,29 @@ class RunTestGMPCrossOrigin : public Bas
{
public:
void Done(typename Base::GMPCodecType* aGMP, GMPVideoHost* aHost) override
{
EXPECT_TRUE(aGMP);
UniquePtr<typename Base::GMPCallbackType> callback(
new Step2(Base::mMonitor, aGMP, mShouldBeEqual));
- nsresult rv = Base::Get(mOrigin2, Move(callback));
+ nsresult rv = Base::Get(mOrigin2, std::move(callback));
EXPECT_TRUE(NS_SUCCEEDED(rv));
if (NS_FAILED(rv)) {
Base::mMonitor.SetFinished();
}
}
static void Run(GMPTestMonitor& aMonitor, const nsCString& aOrigin1,
const nsCString& aOrigin2)
{
UniquePtr<typename Base::GMPCallbackType> callback(
new RunTestGMPCrossOrigin<Base>(aMonitor, aOrigin1, aOrigin2));
- nsresult rv = Base::Get(aOrigin1, Move(callback));
+ nsresult rv = Base::Get(aOrigin1, std::move(callback));
EXPECT_TRUE(NS_SUCCEEDED(rv));
if (NS_FAILED(rv)) {
aMonitor.SetFinished();
}
}
private:
RunTestGMPCrossOrigin(GMPTestMonitor& aMonitor, const nsCString& aOrigin1,
--- a/dom/media/gtest/TestGMPRemoveAndDelete.cpp
+++ b/dom/media/gtest/TestGMPRemoveAndDelete.cpp
@@ -328,17 +328,17 @@ GMPRemoveTest::gmp_GetVideoDecoder(nsCSt
GMPTestMonitor* mMonitor;
GMPVideoDecoderProxy** mDecoder;
GMPVideoHost** mHost;
};
UniquePtr<GetGMPVideoDecoderCallback>
cb(new Callback(&mTestMonitor, aOutDecoder, aOutHost));
- if (NS_FAILED(GetService()->GetGMPVideoDecoder(nullptr, &tags, aNodeId, Move(cb)))) {
+ if (NS_FAILED(GetService()->GetGMPVideoDecoder(nullptr, &tags, aNodeId, std::move(cb)))) {
mTestMonitor.SetFinished();
}
}
void
GMPRemoveTest::CloseVideoDecoder()
{
mGMPThread->Dispatch(NewNonOwningRunnableMethod("GMPVideoDecoderProxy::Close",
@@ -393,17 +393,17 @@ GMPRemoveTest::gmp_Decode()
err = frame->CreateEmptyFrame(sizeof(EncodedFrame) /* size */);
EXPECT_EQ(err, GMPNoErr);
EncodedFrame* frameData = reinterpret_cast<EncodedFrame*>(frame->Buffer());
frameData->magic_ = 0x4652414d;
frameData->width_ = frameData->height_ = 16;
nsTArray<uint8_t> empty;
- nsresult rv = mDecoder->Decode(Move(frame), false /* aMissingFrames */, empty);
+ nsresult rv = mDecoder->Decode(std::move(frame), false /* aMissingFrames */, empty);
EXPECT_OK(rv);
}
void
GMPRemoveTest::Wait()
{
mTestMonitor.AwaitFinished();
}
--- a/dom/media/gtest/TestMP4Demuxer.cpp
+++ b/dom/media/gtest/TestMP4Demuxer.cpp
@@ -46,17 +46,17 @@ public:
EXPECT_EQ(NS_OK, resource->Open());
}
template<typename Function>
void RunTestAndWait(const Function& aFunction)
{
Function func(aFunction);
RefPtr<MP4DemuxerBinding> binding = this;
- mDemuxer->Init()->Then(mTaskQueue, __func__, Move(func), DO_FAIL);
+ mDemuxer->Init()->Then(mTaskQueue, __func__, std::move(func), DO_FAIL);
mTaskQueue->AwaitShutdownAndIdle();
}
RefPtr<GenericPromise>
CheckTrackKeyFrame(MediaTrackDemuxer* aTrackDemuxer)
{
MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
--- a/dom/media/gtest/TestMediaEventSource.cpp
+++ b/dom/media/gtest/TestMediaEventSource.cpp
@@ -364,17 +364,17 @@ TEST(MediaEventSource, NoMove)
auto func2 = [] (RefPtr<RefCounter>&& aEvent) {
EXPECT_EQ(aEvent->mVal, 20);
};
MediaEventListener listener1 = source.Connect(queue, func1);
MediaEventListener listener2 = source.Connect(queue, func2);
// We should copy this rvalue instead of move it in NonExclusive mode.
RefPtr<RefCounter> val = new RefCounter(20);
- source.Notify(Move(val));
+ source.Notify(std::move(val));
queue->BeginShutdown();
queue->AwaitShutdownAndIdle();
listener1.Disconnect();
listener2.Disconnect();
}
/*
@@ -392,14 +392,14 @@ TEST(MediaEventSource, MoveLambda)
// someEvent is copied when captured by the lambda.
EXPECT_EQ(someEvent.mCount, 1);
// someEvent should be copied for we pass |func| as an lvalue.
MediaEventListener listener1 = source.Connect(queue, func);
EXPECT_EQ(someEvent.mCount, 2);
// someEvent should be moved for we pass |func| as an rvalue.
- MediaEventListener listener2 = source.Connect(queue, Move(func));
+ MediaEventListener listener2 = source.Connect(queue, std::move(func));
EXPECT_EQ(someEvent.mCount, 2);
listener1.Disconnect();
listener2.Disconnect();
}
--- a/dom/media/gtest/TestVideoTrackEncoder.cpp
+++ b/dom/media/gtest/TestVideoTrackEncoder.cpp
@@ -283,17 +283,17 @@ TEST(VP8VideoTrackEncoder, FrameEncode)
mozilla::StreamTime(VIDEO_TRACK_RATE),
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromSeconds(i));
}
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(images.Length() * VIDEO_TRACK_RATE);
// Pull Encoded Data back from encoder.
EncodedFrameContainer container;
EXPECT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
}
// Test that encoding a single frame gives useful output.
@@ -306,17 +306,17 @@ TEST(VP8VideoTrackEncoder, SingleFrameEn
generator.Init(mozilla::gfx::IntSize(640, 480));
VideoSegment segment;
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 2), // 1/2 second
generator.GetSize(),
PRINCIPAL_HANDLE_NONE);
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 2);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -348,17 +348,17 @@ TEST(VP8VideoTrackEncoder, SameFrameEnco
mozilla::StreamTime(VIDEO_TRACK_RATE / 10), // 100ms
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromSeconds(i * 0.1));
}
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime((VIDEO_TRACK_RATE / 10) * 15);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -395,17 +395,17 @@ TEST(VP8VideoTrackEncoder, NullFrameFirs
segment.AppendFrame(image.forget(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 10), // 100ms
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromSeconds(0.3));
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(3 * VIDEO_TRACK_RATE / 10);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -434,17 +434,17 @@ TEST(VP8VideoTrackEncoder, SkippedFrames
mozilla::StreamTime(90), // 1ms
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromMilliseconds(i));
}
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(100 * 90);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -482,17 +482,17 @@ TEST(VP8VideoTrackEncoder, RoundingError
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 10), // 100ms
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromSeconds(0.9));
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(10 * VIDEO_TRACK_RATE / 10);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -531,17 +531,17 @@ TEST(VP8VideoTrackEncoder, TimestampFram
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 10), // 0.1s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromSeconds(0.2));
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(3 * VIDEO_TRACK_RATE / 10);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -573,39 +573,39 @@ TEST(VP8VideoTrackEncoder, Suspended)
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 10), // 0.1s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now);
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 10);
encoder.Suspend(now + TimeDuration::FromSeconds(0.1));
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 10), // 0.1s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromSeconds(0.1));
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 10);
encoder.Resume(now + TimeDuration::FromSeconds(0.2));
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 10), // 0.1s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromSeconds(0.2));
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 10);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -635,28 +635,28 @@ TEST(VP8VideoTrackEncoder, SuspendedUnti
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 10), // 0.1s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now);
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 10);
encoder.Suspend(now + TimeDuration::FromSeconds(0.1));
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 10), // 0.1s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromSeconds(0.1));
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 10);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -690,17 +690,17 @@ TEST(VP8VideoTrackEncoder, AlwaysSuspend
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(2 * VIDEO_TRACK_RATE), // 2s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now);
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(2 * VIDEO_TRACK_RATE);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -725,28 +725,28 @@ TEST(VP8VideoTrackEncoder, SuspendedBegi
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 2), // 0.5s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now);
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 2);
encoder.Resume(now + TimeDuration::FromSeconds(0.5));
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 2), // 0.5s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromSeconds(0.5));
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 2);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -777,29 +777,29 @@ TEST(VP8VideoTrackEncoder, SuspendedOver
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE), // 1s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now);
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 2);
encoder.Suspend(now + TimeDuration::FromSeconds(0.5));
// Pass another 1s frame and resume after 0.3 of this new frame.
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE), // 1s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromSeconds(1));
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime((VIDEO_TRACK_RATE / 10) * 8);
encoder.Resume(now + TimeDuration::FromSeconds(1.3));
encoder.AdvanceCurrentTime((VIDEO_TRACK_RATE / 10) * 7);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
@@ -831,17 +831,17 @@ TEST(VP8VideoTrackEncoder, PrematureEndi
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE), // 1s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now);
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 2);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -867,17 +867,17 @@ TEST(VP8VideoTrackEncoder, DelayedStart)
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(2 * VIDEO_TRACK_RATE), // 2s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now);
encoder.SetStartOffset(VIDEO_TRACK_RATE / 2);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 2);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -903,17 +903,17 @@ TEST(VP8VideoTrackEncoder, DelayedStartO
VideoSegment segment;
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(2 * VIDEO_TRACK_RATE), // 2s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.SetStartOffset(VIDEO_TRACK_RATE / 2);
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 2);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -940,17 +940,17 @@ TEST(VP8VideoTrackEncoder, VeryDelayedSt
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE), // 1s
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now);
encoder.SetStartOffset(VIDEO_TRACK_RATE * 10);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 2);
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -1009,17 +1009,17 @@ TEST(VP8VideoTrackEncoder, ShortKeyFrame
mozilla::StreamTime(VIDEO_TRACK_RATE / 1000 * 100), // 100ms
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromMilliseconds(1100));
encoder.SetKeyFrameInterval(500);
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 10 * 12); // 1200ms
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -1098,17 +1098,17 @@ TEST(VP8VideoTrackEncoder, LongKeyFrameI
mozilla::StreamTime(VIDEO_TRACK_RATE / 1000 * 100), // 100ms
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromMilliseconds(2100));
encoder.SetKeyFrameInterval(2000);
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 10 * 22); // 2200ms
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -1185,17 +1185,17 @@ TEST(VP8VideoTrackEncoder, DefaultKeyFra
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 1000 * 100), // 100ms
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromMilliseconds(2100));
encoder.SetStartOffset(0);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 10 * 22); // 2200ms
encoder.NotifyEndOfStream();
EncodedFrameContainer container;
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
EXPECT_TRUE(encoder.IsEncodingComplete());
@@ -1292,17 +1292,17 @@ TEST(VP8VideoTrackEncoder, DynamicKeyFra
mozilla::StreamTime(VIDEO_TRACK_RATE / 1000 * 800), // 800ms
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromMilliseconds(500));
encoder.SetStartOffset(0);
encoder.SetKeyFrameInterval(100);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
// Advancing 501ms, so the first bit of the frame starting at 500ms is
// included. Note the need to compensate this at the end.
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 1000 * 501);
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 1000 * 100), // 100ms
@@ -1328,17 +1328,17 @@ TEST(VP8VideoTrackEncoder, DynamicKeyFra
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 1000 * 100), // 100ms
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromMilliseconds(2500));
encoder.SetKeyFrameInterval(1100);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
// Advancing 2000ms from 501ms to 2501ms
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 1000 * 2000);
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 1000 * 200), // 200ms
generator.GetSize(),
@@ -1354,17 +1354,17 @@ TEST(VP8VideoTrackEncoder, DynamicKeyFra
segment.AppendFrame(generator.GenerateI420Image(),
mozilla::StreamTime(VIDEO_TRACK_RATE / 1000 * 100), // 100ms
generator.GetSize(),
PRINCIPAL_HANDLE_NONE,
false,
now + TimeDuration::FromMilliseconds(2900));
encoder.SetKeyFrameInterval(200);
- encoder.AppendVideoSegment(Move(segment));
+ encoder.AppendVideoSegment(std::move(segment));
// Advancing 499ms (compensating back 1ms from the first advancement)
// from 2501ms to 3000ms.
encoder.AdvanceCurrentTime(VIDEO_TRACK_RATE / 1000 * 499);
encoder.NotifyEndOfStream();
ASSERT_TRUE(NS_SUCCEEDED(encoder.GetEncodedTrack(container)));
--- a/dom/media/hls/HLSDemuxer.cpp
+++ b/dom/media/hls/HLSDemuxer.cpp
@@ -258,17 +258,17 @@ HLSDemuxer::~HLSDemuxer()
}
HLSTrackDemuxer::HLSTrackDemuxer(HLSDemuxer* aParent,
TrackInfo::TrackType aType,
UniquePtr<TrackInfo> aTrackInfo)
: mParent(aParent)
, mType(aType)
, mMutex("HLSTrackDemuxer")
- , mTrackInfo(Move(aTrackInfo))
+ , mTrackInfo(std::move(aTrackInfo))
{
// Only support audio and video track currently.
MOZ_ASSERT(mType == TrackInfo::kVideoTrack || mType == TrackInfo::kAudioTrack);
UpdateMediaInfo(0);
}
UniquePtr<TrackInfo>
HLSTrackDemuxer::GetInfo() const
@@ -343,17 +343,17 @@ HLSTrackDemuxer::DoGetSamples(int32_t aN
: mParent->mHLSDemuxerWrapper->GetSamples(TrackInfo::kVideoTrack, aNumSamples);
nsTArray<jni::Object::LocalRef> sampleObjectArray(demuxedSamples->GetElements());
if (sampleObjectArray.IsEmpty()) {
return SamplesPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA, __func__);
}
for (auto&& demuxedSample : sampleObjectArray) {
- java::GeckoHLSSample::LocalRef sample(Move(demuxedSample));
+ java::GeckoHLSSample::LocalRef sample(std::move(demuxedSample));
if (sample->IsEOS()) {
HLS_DEBUG("HLSTrackDemuxer", "Met BUFFER_FLAG_END_OF_STREAM.");
if (samples->mSamples.IsEmpty()) {
return SamplesPromise::CreateAndReject(NS_ERROR_DOM_MEDIA_END_OF_STREAM,
__func__);
}
mQueuedSample = new MediaRawData();
mQueuedSample->mEOS = true;
@@ -382,33 +382,33 @@ HLSTrackDemuxer::UpdateMediaInfo(int ind
MOZ_ASSERT(mParent->mHLSDemuxerWrapper);
MutexAutoLock lock(mMutex);
jni::Object::LocalRef infoObj = nullptr;
if (mType == TrackType::kAudioTrack) {
infoObj = mParent->mHLSDemuxerWrapper->GetAudioInfo(index);
auto* audioInfo = mTrackInfo->GetAsAudioInfo();
if (infoObj && audioInfo) {
HLS_DEBUG("HLSTrackDemuxer", "Update audio info (%d)", index);
- java::GeckoAudioInfo::LocalRef audioInfoObj(Move(infoObj));
+ java::GeckoAudioInfo::LocalRef audioInfoObj(std::move(infoObj));
audioInfo->mRate = audioInfoObj->Rate();
audioInfo->mChannels = audioInfoObj->Channels();
audioInfo->mProfile = audioInfoObj->Profile();
audioInfo->mBitDepth = audioInfoObj->BitDepth();
audioInfo->mMimeType = NS_ConvertUTF16toUTF8(audioInfoObj->MimeType()->ToString());
audioInfo->mDuration = TimeUnit::FromMicroseconds(audioInfoObj->Duration());
auto&& csd = audioInfoObj->CodecSpecificData()->GetElements();
audioInfo->mCodecSpecificConfig->Clear();
audioInfo->mCodecSpecificConfig->AppendElements(reinterpret_cast<uint8_t*>(&csd[0]),
csd.Length());
}
} else {
infoObj = mParent->mHLSDemuxerWrapper->GetVideoInfo(index);
auto* videoInfo = mTrackInfo->GetAsVideoInfo();
if (infoObj && videoInfo) {
- java::GeckoVideoInfo::LocalRef videoInfoObj(Move(infoObj));
+ java::GeckoVideoInfo::LocalRef videoInfoObj(std::move(infoObj));
videoInfo->mStereoMode = getStereoMode(videoInfoObj->StereoMode());
videoInfo->mRotation = getVideoInfoRotation(videoInfoObj->Rotation());
videoInfo->mImage.width = videoInfoObj->DisplayWidth();
videoInfo->mImage.height = videoInfoObj->DisplayHeight();
videoInfo->mDisplay.width = videoInfoObj->PictureWidth();
videoInfo->mDisplay.height = videoInfoObj->PictureHeight();
videoInfo->mMimeType = NS_ConvertUTF16toUTF8(videoInfoObj->MimeType()->ToString());
videoInfo->mDuration = TimeUnit::FromMicroseconds(videoInfoObj->Duration());
@@ -594,17 +594,17 @@ HLSTrackDemuxer::DoSkipToNextRandomAcces
mozilla::jni::ObjectArray::LocalRef demuxedSamples =
mParent->mHLSDemuxerWrapper->GetSamples(mType, 1);
nsTArray<jni::Object::LocalRef> sampleObjectArray(demuxedSamples->GetElements());
if (sampleObjectArray.IsEmpty()) {
result = NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA;
break;
}
parsed++;
- java::GeckoHLSSample::LocalRef sample(Move(sampleObjectArray[0]));
+ java::GeckoHLSSample::LocalRef sample(std::move(sampleObjectArray[0]));
if (sample->IsEOS()) {
result = NS_ERROR_DOM_MEDIA_END_OF_STREAM;
break;
}
if (sample->IsKeyFrame()) {
java::sdk::BufferInfo::LocalRef info = sample->Info();
int64_t presentationTimeUs = 0;
bool ok = NS_SUCCEEDED(info->PresentationTimeUs(&presentationTimeUs));
--- a/dom/media/ipc/VideoDecoderChild.cpp
+++ b/dom/media/ipc/VideoDecoderChild.cpp
@@ -68,17 +68,17 @@ VideoDecoderChild::RecvOutput(const Vide
aData.display(),
aData.base().offset(),
media::TimeUnit::FromMicroseconds(aData.base().time()),
media::TimeUnit::FromMicroseconds(aData.base().duration()),
image,
aData.base().keyframe(),
media::TimeUnit::FromMicroseconds(aData.base().timecode()));
- mDecodedData.AppendElement(Move(video));
+ mDecodedData.AppendElement(std::move(video));
return IPC_OK();
}
mozilla::ipc::IPCResult
VideoDecoderChild::RecvInputExhausted()
{
AssertOnManagerThread();
mDecodePromise.ResolveIfExists(mDecodedData, __func__);
--- a/dom/media/ipc/VideoDecoderManagerChild.cpp
+++ b/dom/media/ipc/VideoDecoderManagerChild.cpp
@@ -48,17 +48,17 @@ VideoDecoderManagerChild::InitializeThre
}
}
/* static */ void
VideoDecoderManagerChild::InitForContent(Endpoint<PVideoDecoderManagerChild>&& aVideoManager)
{
InitializeThread();
sVideoDecoderChildThread->Dispatch(NewRunnableFunction("InitForContentRunnable",
- &Open, Move(aVideoManager)), NS_DISPATCH_NORMAL);
+ &Open, std::move(aVideoManager)), NS_DISPATCH_NORMAL);
}
/* static */ void
VideoDecoderManagerChild::Shutdown()
{
MOZ_ASSERT(NS_IsMainThread());
if (sVideoDecoderChildThread) {
@@ -261,17 +261,17 @@ VideoDecoderManagerChild::Readback(const
return source.forget();
}
void
VideoDecoderManagerChild::DeallocateSurfaceDescriptorGPUVideo(const SurfaceDescriptorGPUVideo& aSD)
{
RefPtr<VideoDecoderManagerChild> ref = this;
- SurfaceDescriptorGPUVideo sd = Move(aSD);
+ SurfaceDescriptorGPUVideo sd = std::move(aSD);
sVideoDecoderChildThread->Dispatch(
NS_NewRunnableFunction(
"dom::VideoDecoderManagerChild::DeallocateSurfaceDescriptorGPUVideo",
[ref, sd]() {
if (ref->CanSend()) {
ref->SendDeallocateSurfaceDescriptorGPUVideo(sd);
}
}),
--- a/dom/media/ipc/VideoDecoderManagerParent.cpp
+++ b/dom/media/ipc/VideoDecoderManagerParent.cpp
@@ -39,17 +39,17 @@ using namespace gfx;
SurfaceDescriptorGPUVideo
VideoDecoderManagerParent::StoreImage(Image* aImage, TextureClient* aTexture)
{
SurfaceDescriptorGPUVideo ret;
aTexture->GPUVideoDesc(&ret);
mImageMap[ret.handle()] = aImage;
mTextureMap[ret.handle()] = aTexture;
- return Move(ret);
+ return std::move(ret);
}
StaticRefPtr<nsIThread> sVideoDecoderManagerThread;
StaticRefPtr<TaskQueue> sManagerTaskQueue;
class VideoDecoderManagerThreadHolder
{
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VideoDecoderManagerThreadHolder)
@@ -173,17 +173,17 @@ VideoDecoderManagerParent::CreateForCont
RefPtr<VideoDecoderManagerParent> parent =
new VideoDecoderManagerParent(sVideoDecoderManagerThreadHolder);
RefPtr<Runnable> task =
NewRunnableMethod<Endpoint<PVideoDecoderManagerParent>&&>(
"dom::VideoDecoderManagerParent::Open",
parent,
&VideoDecoderManagerParent::Open,
- Move(aEndpoint));
+ std::move(aEndpoint));
sVideoDecoderManagerThread->Dispatch(task.forget(), NS_DISPATCH_NORMAL);
return true;
}
VideoDecoderManagerParent::VideoDecoderManagerParent(VideoDecoderManagerThreadHolder* aHolder)
: mThreadHolder(aHolder)
{
MOZ_COUNT_CTOR(VideoDecoderManagerParent);
--- a/dom/media/mediasink/AudioSink.cpp
+++ b/dom/media/mediasink/AudioSink.cpp
@@ -431,36 +431,36 @@ AudioSink::NotifyAudioNeeded()
AlignedAudioBuffer silenceBuffer(missingFrames.value() * data->mChannels);
if (!silenceBuffer) {
NS_WARNING("OOM in AudioSink");
mErrored = true;
return;
}
if (mConverter->InputConfig() != mConverter->OutputConfig()) {
AlignedAudioBuffer convertedData =
- mConverter->Process(AudioSampleBuffer(Move(silenceBuffer))).Forget();
- silenceData = CreateAudioFromBuffer(Move(convertedData), data);
+ mConverter->Process(AudioSampleBuffer(std::move(silenceBuffer))).Forget();
+ silenceData = CreateAudioFromBuffer(std::move(convertedData), data);
} else {
- silenceData = CreateAudioFromBuffer(Move(silenceBuffer), data);
+ silenceData = CreateAudioFromBuffer(std::move(silenceBuffer), data);
}
PushProcessedAudio(silenceData);
}
mLastEndTime = data->GetEndTime();
mFramesParsed += data->mFrames;
if (mConverter->InputConfig() != mConverter->OutputConfig()) {
// We must ensure that the size in the buffer contains exactly the number
// of frames, in case one of the audio producer over allocated the buffer.
- AlignedAudioBuffer buffer(Move(data->mAudioData));
+ AlignedAudioBuffer buffer(std::move(data->mAudioData));
buffer.SetLength(size_t(data->mFrames) * data->mChannels);
AlignedAudioBuffer convertedData =
- mConverter->Process(AudioSampleBuffer(Move(buffer))).Forget();
- data = CreateAudioFromBuffer(Move(convertedData), data);
+ mConverter->Process(AudioSampleBuffer(std::move(buffer))).Forget();
+ data = CreateAudioFromBuffer(std::move(convertedData), data);
}
if (PushProcessedAudio(data)) {
mLastProcessedPacket = Some(data);
}
}
if (mAudioQueue.IsFinished()) {
// We have reached the end of the data, drain the resampler.
@@ -494,17 +494,17 @@ AudioSink::CreateAudioFromBuffer(Aligned
mErrored = true;
return nullptr;
}
RefPtr<AudioData> data =
new AudioData(aReference->mOffset,
aReference->mTime,
duration,
frames,
- Move(aBuffer),
+ std::move(aBuffer),
mOutputChannels,
mOutputRate);
return data.forget();
}
uint32_t
AudioSink::DrainConverter(uint32_t aMaxFrames)
{
@@ -525,17 +525,17 @@ AudioSink::DrainConverter(uint32_t aMaxF
uint32_t frames = convertedData.Length() / mOutputChannels;
if (!convertedData.SetLength(std::min(frames, aMaxFrames) * mOutputChannels)) {
// This can never happen as we were reducing the length of convertData.
mErrored = true;
return 0;
}
RefPtr<AudioData> data =
- CreateAudioFromBuffer(Move(convertedData), lastPacket);
+ CreateAudioFromBuffer(std::move(convertedData), lastPacket);
if (!data) {
return 0;
}
mProcessedQueue.Push(data);
return data->mFrames;
}
nsCString
--- a/dom/media/mediasink/AudioSinkWrapper.cpp
+++ b/dom/media/mediasink/AudioSinkWrapper.cpp
@@ -253,14 +253,14 @@ AudioSinkWrapper::GetDebugInfo()
auto str =
nsPrintfCString("AudioSinkWrapper: IsStarted=%d IsPlaying=%d AudioEnded=%d",
IsStarted(),
IsPlaying(),
mAudioEnded);
if (mAudioSink) {
AppendStringIfNotEmpty(str, mAudioSink->GetDebugInfo());
}
- return Move(str);
+ return std::move(str);
}
} // namespace media
} // namespace mozilla
--- a/dom/media/mediasink/DecodedStream.cpp
+++ b/dom/media/mediasink/DecodedStream.cpp
@@ -37,17 +37,17 @@ class DecodedStreamGraphListener : publi
public:
DecodedStreamGraphListener(MediaStream* aStream,
MozPromiseHolder<GenericPromise>&& aPromise,
AbstractThread* aMainThread)
: mMutex("DecodedStreamGraphListener::mMutex")
, mStream(aStream)
, mAbstractMainThread(aMainThread)
{
- mFinishPromise = Move(aPromise);
+ mFinishPromise = std::move(aPromise);
}
void NotifyOutput(MediaStreamGraph* aGraph, GraphTime aCurrentTime) override
{
MutexAutoLock lock(mMutex);
if (mStream) {
int64_t t = mStream->StreamTimeToMicroseconds(
mStream->GraphTimeToStreamTime(aCurrentTime));
@@ -179,17 +179,17 @@ DecodedStreamData::DecodedStreamData(Out
: mAudioFramesWritten(0)
, mNextVideoTime(aInit.mStartTime)
, mNextAudioTime(aInit.mStartTime)
, mHaveSentFinish(false)
, mHaveSentFinishAudio(false)
, mHaveSentFinishVideo(false)
, mStream(aOutputStreamManager->Graph()->CreateSourceStream())
// DecodedStreamGraphListener will resolve this promise.
- , mListener(new DecodedStreamGraphListener(mStream, Move(aPromise), aMainThread))
+ , mListener(new DecodedStreamGraphListener(mStream, std::move(aPromise), aMainThread))
// mPlaying is initially true because MDSM won't start playback until playing
// becomes true. This is consistent with the settings of AudioSink.
, mPlaying(true)
, mEOSVideoCompensation(false)
, mOutputStreamManager(aOutputStreamManager)
, mAbstractMainThread(aMainThread)
{
mStream->AddListener(mListener);
@@ -312,55 +312,55 @@ DecodedStream::Start(const TimeUnit& aSt
ConnectListener();
class R : public Runnable {
typedef MozPromiseHolder<GenericPromise> Promise;
public:
R(PlaybackInfoInit&& aInit, Promise&& aPromise,
OutputStreamManager* aManager, AbstractThread* aMainThread)
: Runnable("CreateDecodedStreamData")
- , mInit(Move(aInit))
+ , mInit(std::move(aInit))
, mOutputStreamManager(aManager)
, mAbstractMainThread(aMainThread)
{
- mPromise = Move(aPromise);
+ mPromise = std::move(aPromise);
}
NS_IMETHOD Run() override
{
MOZ_ASSERT(NS_IsMainThread());
// No need to create a source stream when there are no output streams. This
// happens when RemoveOutput() is called immediately after StartPlayback().
if (!mOutputStreamManager->Graph()) {
// Resolve the promise to indicate the end of playback.
mPromise.Resolve(true, __func__);
return NS_OK;
}
mData = MakeUnique<DecodedStreamData>(
- mOutputStreamManager, Move(mInit), Move(mPromise), mAbstractMainThread);
+ mOutputStreamManager, std::move(mInit), std::move(mPromise), mAbstractMainThread);
return NS_OK;
}
UniquePtr<DecodedStreamData> ReleaseData()
{
- return Move(mData);
+ return std::move(mData);
}
private:
PlaybackInfoInit mInit;
Promise mPromise;
RefPtr<OutputStreamManager> mOutputStreamManager;
UniquePtr<DecodedStreamData> mData;
const RefPtr<AbstractThread> mAbstractMainThread;
};
MozPromiseHolder<GenericPromise> promise;
mFinishPromise = promise.Ensure(__func__);
PlaybackInfoInit init {
aStartTime, aInfo
};
nsCOMPtr<nsIRunnable> r =
- new R(Move(init), Move(promise), mOutputStreamManager, mAbstractMainThread);
+ new R(std::move(init), std::move(promise), mOutputStreamManager, mAbstractMainThread);
SyncRunnable::DispatchToThread(
SystemGroup::EventTargetFor(mozilla::TaskCategory::Other), r);
mData = static_cast<R*>(r.get())->ReleaseData();
if (mData) {
mOutputListener = mData->OnOutput().Connect(
mOwnerThread, this, &DecodedStream::NotifyOutput);
mData->SetPlaying(mPlaying);
@@ -375,17 +375,17 @@ DecodedStream::Stop()
MOZ_ASSERT(mStartTime.isSome(), "playback not started.");
mStartTime.reset();
DisconnectListener();
mFinishPromise = nullptr;
// Clear mData immediately when this playback session ends so we won't
// send data to the wrong stream in SendData() in next playback session.
- DestroyData(Move(mData));
+ DestroyData(std::move(mData));
}
bool
DecodedStream::IsStarted() const
{
AssertOwnerThread();
return mStartTime.isSome();
}
@@ -797,12 +797,12 @@ DecodedStream::GetDebugInfo()
this,
startTime,
mLastOutputTime.ToMicroseconds(),
mPlaying,
mData.get());
if (mData) {
AppendStringIfNotEmpty(str, mData->GetDebugInfo());
}
- return Move(str);
+ return std::move(str);
}
} // namespace mozilla
--- a/dom/media/mediasink/VideoSink.cpp
+++ b/dom/media/mediasink/VideoSink.cpp
@@ -558,13 +558,13 @@ VideoSink::GetDebugInfo()
IsPlaying(),
VideoQueue().IsFinished(),
VideoQueue().GetSize(),
mVideoFrameEndTime.ToMicroseconds(),
mHasVideo,
mVideoSinkEndRequest.Exists(),
mEndPromiseHolder.IsEmpty());
AppendStringIfNotEmpty(str, mAudioSink->GetDebugInfo());
- return Move(str);
+ return std::move(str);
}
} // namespace media
} // namespace mozilla
--- a/dom/media/mediasource/AutoTaskQueue.h
+++ b/dom/media/mediasource/AutoTaskQueue.h
@@ -17,40 +17,40 @@ namespace mozilla {
// A convenience TaskQueue not requiring explicit shutdown.
class AutoTaskQueue : public AbstractThread
{
public:
explicit AutoTaskQueue(already_AddRefed<nsIEventTarget> aPool,
bool aSupportsTailDispatch = false)
: AbstractThread(aSupportsTailDispatch)
- , mTaskQueue(new TaskQueue(Move(aPool), aSupportsTailDispatch))
+ , mTaskQueue(new TaskQueue(std::move(aPool), aSupportsTailDispatch))
, mMonitor("AutoTaskQueue")
{
}
AutoTaskQueue(already_AddRefed<nsIEventTarget> aPool,
const char* aName,
bool aSupportsTailDispatch = false)
: AbstractThread(aSupportsTailDispatch)
- , mTaskQueue(new TaskQueue(Move(aPool), aName, aSupportsTailDispatch))
+ , mTaskQueue(new TaskQueue(std::move(aPool), aName, aSupportsTailDispatch))
, mMonitor("AutoTaskQueue")
{
}
TaskDispatcher& TailDispatcher() override
{
return mTaskQueue->TailDispatcher();
}
MOZ_MUST_USE nsresult
Dispatch(already_AddRefed<nsIRunnable> aRunnable,
DispatchReason aReason = NormalDispatch) override
{
- return mTaskQueue->Dispatch(Move(aRunnable), aReason);
+ return mTaskQueue->Dispatch(std::move(aRunnable), aReason);
}
// Prevent a GCC warning about the other overload of Dispatch being hidden.
using AbstractThread::Dispatch;
// Blocks until all tasks finish executing.
void AwaitIdle() { mTaskQueue->AwaitIdle(); }
--- a/dom/media/mediasource/MediaSource.cpp
+++ b/dom/media/mediasource/MediaSource.cpp
@@ -301,17 +301,17 @@ MediaSource::SourceBufferIsActive(Source
}
mDecoder->NotifyInitDataArrived();
// Add our promise to the queue.
// It will be resolved once the HTMLMediaElement modifies its readyState.
MozPromiseHolder<ActiveCompletionPromise> holder;
RefPtr<ActiveCompletionPromise> promise = holder.Ensure(__func__);
- mCompletionPromises.AppendElement(Move(holder));
+ mCompletionPromises.AppendElement(std::move(holder));
return promise;
}
void
MediaSource::CompletePendingTransactions()
{
MOZ_ASSERT(NS_IsMainThread());
MSE_DEBUG("Resolving %u promises", unsigned(mCompletionPromises.Length()));
--- a/dom/media/mediasource/MediaSourceDemuxer.cpp
+++ b/dom/media/mediasource/MediaSourceDemuxer.cpp
@@ -181,17 +181,17 @@ MediaSourceDemuxer::AttachSourceBuffer(
Unused << rv;
}
void
MediaSourceDemuxer::DoAttachSourceBuffer(
RefPtr<mozilla::TrackBuffersManager>&& aSourceBuffer)
{
MOZ_ASSERT(OnTaskQueue());
- mSourceBuffers.AppendElement(Move(aSourceBuffer));
+ mSourceBuffers.AppendElement(std::move(aSourceBuffer));
ScanSourceBuffersForContent();
}
void
MediaSourceDemuxer::DetachSourceBuffer(
RefPtr<TrackBuffersManager>& aSourceBuffer)
{
nsCOMPtr<nsIRunnable> task = NewRunnableMethod<RefPtr<TrackBuffersManager>&&>(
--- a/dom/media/mediasource/TrackBuffersManager.cpp
+++ b/dom/media/mediasource/TrackBuffersManager.cpp
@@ -159,17 +159,17 @@ TrackBuffersManager::AppendData(already_
data.forget(),
aAttributes);
}
RefPtr<TrackBuffersManager::AppendPromise>
TrackBuffersManager::DoAppendData(already_AddRefed<MediaByteBuffer> aData,
const SourceBufferAttributes& aAttributes)
{
- RefPtr<AppendBufferTask> task = new AppendBufferTask(Move(aData), aAttributes);
+ RefPtr<AppendBufferTask> task = new AppendBufferTask(std::move(aData), aAttributes);
RefPtr<AppendPromise> p = task->mPromise.Ensure(__func__);
QueueTask(task);
return p;
}
void
TrackBuffersManager::QueueTask(SourceBufferTask* aTask)
--- a/dom/media/mediasource/TrackBuffersManager.h
+++ b/dom/media/mediasource/TrackBuffersManager.h
@@ -47,17 +47,17 @@ public:
mQueue.AppendElement(aTask);
}
already_AddRefed<SourceBufferTask> Pop()
{
if (!mQueue.Length()) {
return nullptr;
}
- RefPtr<SourceBufferTask> task = Move(mQueue[0]);
+ RefPtr<SourceBufferTask> task = std::move(mQueue[0]);
mQueue.RemoveElementAt(0);
return task.forget();
}
nsTArray<RefPtr<SourceBufferTask>>::size_type Length() const
{
return mQueue.Length();
}
--- a/dom/media/mp4/MP4Decoder.cpp
+++ b/dom/media/mp4/MP4Decoder.cpp
@@ -117,17 +117,17 @@ MP4Decoder::IsSupportedType(const MediaC
CreateTrackInfoWithMIMETypeAndContainerTypeExtraParameters(
NS_LITERAL_CSTRING("video/vp9"), aType);
uint8_t profile = 0;
uint8_t level = 0;
uint8_t bitDepth = 0;
if (ExtractVPXCodecDetails(codec, profile, level, bitDepth)) {
trackInfo->GetAsVideoInfo()->mBitDepth = bitDepth;
}
- trackInfos.AppendElement(Move(trackInfo));
+ trackInfos.AppendElement(std::move(trackInfo));
continue;
}
// Note: Only accept H.264 in a video content type, not in an audio
// content type.
if (IsWhitelistedH264Codec(codec) && isVideo) {
trackInfos.AppendElement(
CreateTrackInfoWithMIMETypeAndContainerTypeExtraParameters(
NS_LITERAL_CSTRING("video/avc"), aType));
--- a/dom/media/mp4/MP4Demuxer.cpp
+++ b/dom/media/mp4/MP4Demuxer.cpp
@@ -141,22 +141,22 @@ MP4Demuxer::Init()
// 'result' will capture the first warning, if any.
MediaResult result{NS_OK};
MP4Metadata::ResultAndByteBuffer initData =
MP4Metadata::Metadata(stream);
if (!initData.Ref()) {
return InitPromise::CreateAndReject(
NS_FAILED(initData.Result())
- ? Move(initData.Result())
+ ? std::move(initData.Result())
: MediaResult(NS_ERROR_DOM_MEDIA_DEMUXER_ERR,
RESULT_DETAIL("Invalid MP4 metadata or OOM")),
__func__);
} else if (NS_FAILED(initData.Result()) && result == NS_OK) {
- result = Move(initData.Result());
+ result = std::move(initData.Result());
}
RefPtr<BufferStream> bufferstream =
new BufferStream(initData.Ref());
MP4Metadata metadata{bufferstream};
DDLINKCHILD("metadata", &metadata);
nsresult rv = metadata.Parse();
@@ -194,20 +194,20 @@ MP4Demuxer::Init()
MediaResult(NS_ERROR_DOM_MEDIA_DEMUXER_ERR,
RESULT_DETAIL("No MP4 audio (%s) or video (%s) tracks",
audioTrackCount.Result().Description().get(),
videoTrackCount.Result().Description().get())),
__func__);
}
if (NS_FAILED(audioTrackCount.Result()) && result == NS_OK) {
- result = Move(audioTrackCount.Result());
+ result = std::move(audioTrackCount.Result());
}
if (NS_FAILED(videoTrackCount.Result()) && result == NS_OK) {
- result = Move(videoTrackCount.Result());
+ result = std::move(videoTrackCount.Result());
}
if (audioTrackCount.Ref() != 0) {
for (size_t i = 0; i < audioTrackCount.Ref(); i++) {
MP4Metadata::ResultAndTrackInfo info =
metadata.GetTrackInfo(TrackInfo::kAudioTrack, i);
if (!info.Ref()) {
if (StaticPrefs::MediaPlaybackWarningsAsErrors()) {
@@ -219,30 +219,30 @@ MP4Demuxer::Init()
}
if (result == NS_OK) {
result = MediaResult(NS_ERROR_DOM_MEDIA_DEMUXER_ERR,
RESULT_DETAIL("Invalid MP4 audio track (%s)",
info.Result().Description().get()));
}
continue;
} else if (NS_FAILED(info.Result()) && result == NS_OK) {
- result = Move(info.Result());
+ result = std::move(info.Result());
}
MP4Metadata::ResultAndIndice indices =
metadata.GetTrackIndice(info.Ref()->mTrackId);
if (!indices.Ref()) {
if (NS_FAILED(info.Result()) && result == NS_OK) {
- result = Move(indices.Result());
+ result = std::move(indices.Result());
}
continue;
}
RefPtr<MP4TrackDemuxer> demuxer =
- new MP4TrackDemuxer(this, Move(info.Ref()), *indices.Ref().get());
+ new MP4TrackDemuxer(this, std::move(info.Ref()), *indices.Ref().get());
DDLINKCHILD("audio demuxer", demuxer.get());
- mAudioDemuxers.AppendElement(Move(demuxer));
+ mAudioDemuxers.AppendElement(std::move(demuxer));
}
}
if (videoTrackCount.Ref() != 0) {
for (size_t i = 0; i < videoTrackCount.Ref(); i++) {
MP4Metadata::ResultAndTrackInfo info =
metadata.GetTrackInfo(TrackInfo::kVideoTrack, i);
if (!info.Ref()) {
@@ -255,37 +255,37 @@ MP4Demuxer::Init()
}
if (result == NS_OK) {
result = MediaResult(NS_ERROR_DOM_MEDIA_DEMUXER_ERR,
RESULT_DETAIL("Invalid MP4 video track (%s)",
info.Result().Description().get()));
}
continue;
} else if (NS_FAILED(info.Result()) && result == NS_OK) {
- result = Move(info.Result());
+ result = std::move(info.Result());
}
MP4Metadata::ResultAndIndice indices =
metadata.GetTrackIndice(info.Ref()->mTrackId);
if (!indices.Ref()) {
if (NS_FAILED(info.Result()) && result == NS_OK) {
- result = Move(indices.Result());
+ result = std::move(indices.Result());
}
continue;
}
RefPtr<MP4TrackDemuxer> demuxer =
- new MP4TrackDemuxer(this, Move(info.Ref()), *indices.Ref().get());
+ new MP4TrackDemuxer(this, std::move(info.Ref()), *indices.Ref().get());
DDLINKCHILD("video demuxer", demuxer.get());
- mVideoDemuxers.AppendElement(Move(demuxer));
+ mVideoDemuxers.AppendElement(std::move(demuxer));
}
}
MP4Metadata::ResultAndCryptoFile cryptoFile =
metadata.Crypto();
if (NS_FAILED(cryptoFile.Result()) && result == NS_OK) {
- result = Move(cryptoFile.Result());
+ result = std::move(cryptoFile.Result());
}
MOZ_ASSERT(cryptoFile.Ref());
if (cryptoFile.Ref()->valid) {
const nsTArray<PsshInfo>& psshs = cryptoFile.Ref()->pssh;
for (uint32_t i = 0; i < psshs.Length(); i++) {
mCryptoInitData.AppendElements(psshs[i].data);
}
}
@@ -363,17 +363,17 @@ MP4Demuxer::GetCrypto()
return crypto;
}
MP4TrackDemuxer::MP4TrackDemuxer(MP4Demuxer* aParent,
UniquePtr<TrackInfo>&& aInfo,
const IndiceWrapper& aIndices)
: mParent(aParent)
, mStream(new ResourceStream(mParent->mResource))
- , mInfo(Move(aInfo))
+ , mInfo(std::move(aInfo))
, mIndex(new Index(aIndices,
mStream,
mInfo->mTrackId,
mInfo->IsAudio()))
, mIterator(MakeUnique<SampleIterator>(mIndex))
, mNeedReIndex(true)
{
EnsureUpToDateIndex(); // Force update of index
@@ -611,17 +611,17 @@ MP4TrackDemuxer::SkipToNextRandomAccessP
mQueuedSample = sample;
}
}
SetNextKeyFrameTime();
if (found) {
return SkipAccessPointPromise::CreateAndResolve(parsed, __func__);
}
SkipFailureHolder failure(NS_ERROR_DOM_MEDIA_END_OF_STREAM, parsed);
- return SkipAccessPointPromise::CreateAndReject(Move(failure), __func__);
+ return SkipAccessPointPromise::CreateAndReject(std::move(failure), __func__);
}
media::TimeIntervals
MP4TrackDemuxer::GetBuffered()
{
EnsureUpToDateIndex();
AutoPinned<MediaResource> resource(mParent->mResource);
MediaByteRangeSet byteRanges;
--- a/dom/media/mp4/MP4Metadata.cpp
+++ b/dom/media/mp4/MP4Metadata.cpp
@@ -275,33 +275,33 @@ MP4Metadata::GetTrackInfo(mozilla::Track
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
RESULT_DETAIL("Cannot parse %s track #%zu",
TrackTypeToStr(aType),
aTrackNumber)),
nullptr};
}
auto track = mozilla::MakeUnique<MP4AudioInfo>();
track->Update(&info, &audio);
- e = Move(track);
+ e = std::move(track);
}
break;
case TrackInfo::TrackType::kVideoTrack: {
Mp4parseTrackVideoInfo video;
auto rv = mp4parse_get_track_video_info(mParser.get(), trackIndex.value(), &video);
if (rv != MP4PARSE_STATUS_OK) {
MOZ_LOG(gMP4MetadataLog, LogLevel::Warning, ("mp4parse_get_track_video_info returned error %d", rv));
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
RESULT_DETAIL("Cannot parse %s track #%zu",
TrackTypeToStr(aType),
aTrackNumber)),
nullptr};
}
auto track = mozilla::MakeUnique<MP4VideoInfo>();
track->Update(&info, &video);
- e = Move(track);
+ e = std::move(track);
}
break;
default:
MOZ_LOG(gMP4MetadataLog, LogLevel::Warning, ("unhandled track type %d", aType));
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
RESULT_DETAIL("Cannot handle %s track #%zu",
TrackTypeToStr(aType),
aTrackNumber)),
@@ -313,17 +313,17 @@ MP4Metadata::GetTrackInfo(mozilla::Track
Mp4parseFragmentInfo info;
auto rv = mp4parse_get_fragment_info(mParser.get(), &info);
if (rv == MP4PARSE_STATUS_OK) {
e->mDuration = TimeUnit::FromMicroseconds(info.fragment_duration);
}
}
if (e && e->IsValid()) {
- return {NS_OK, Move(e)};
+ return {NS_OK, std::move(e)};
}
MOZ_LOG(gMP4MetadataLog, LogLevel::Debug, ("TrackInfo didn't validate"));
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
RESULT_DETAIL("Invalid %s track #%zu",
TrackTypeToStr(aType),
aTrackNumber)),
nullptr};
@@ -365,25 +365,25 @@ MP4Metadata::GetTrackIndice(mozilla::Tra
int(aTrackID), int(rv))),
nullptr};
}
}
UniquePtr<IndiceWrapper> indice;
indice = mozilla::MakeUnique<IndiceWrapper>(indiceRawData);
- return {NS_OK, Move(indice)};
+ return {NS_OK, std::move(indice)};
}
/*static*/ MP4Metadata::ResultAndByteBuffer
MP4Metadata::Metadata(ByteStream* aSource)
{
auto parser = mozilla::MakeUnique<MoofParser>(aSource, 0, false);
RefPtr<mozilla::MediaByteBuffer> buffer = parser->Metadata();
if (!buffer) {
return {MediaResult(NS_ERROR_DOM_MEDIA_METADATA_ERR,
RESULT_DETAIL("Cannot parse metadata")),
nullptr};
}
- return {NS_OK, Move(buffer)};
+ return {NS_OK, std::move(buffer)};
}
} // namespace mozilla
--- a/dom/media/ogg/OggCodecState.cpp
+++ b/dom/media/ogg/OggCodecState.cpp
@@ -293,22 +293,22 @@ OggCodecState::PacketOutUntilGranulepos(
// come out, or we get a data packet with non -1 granulepos.
do {
ogg_packet packet;
r = ogg_stream_packetout(&mState, &packet);
if (r == 1) {
OggPacketPtr clone = Clone(&packet);
if (IsHeader(&packet)) {
// Header packets go straight into the packet queue.
- mPackets.Append(Move(clone));
+ mPackets.Append(std::move(clone));
} else {
// We buffer data packets until we encounter a granulepos. We'll
// then use the granulepos to figure out the granulepos of the
// preceeding packets.
- mUnstamped.AppendElement(Move(clone));
+ mUnstamped.AppendElement(std::move(clone));
aFoundGranulepos = packet.granulepos > 0;
}
}
} while (r != 0 && !aFoundGranulepos);
if (ogg_stream_check(&mState)) {
NS_WARNING("Unrecoverable error in ogg_stream_packetout");
return NS_ERROR_FAILURE;
}
@@ -381,17 +381,17 @@ TheoraState::Reset()
mHeaders.Erase();
return OggCodecState::Reset();
}
bool
TheoraState::DecodeHeader(OggPacketPtr aPacket)
{
ogg_packet* packet = aPacket.get(); // Will be owned by mHeaders.
- mHeaders.Append(Move(aPacket));
+ mHeaders.Append(std::move(aPacket));
mPacketCount++;
int ret = th_decode_headerin(&mTheoraInfo,
&mComment,
&mSetup,
packet);
// We must determine when we've read the last header packet.
// th_decode_headerin() does not tell us when it's read the last header, so
@@ -528,22 +528,22 @@ TheoraState::PageIn(ogg_page* aPage)
nsresult res = PacketOutUntilGranulepos(foundGp);
if (NS_FAILED(res))
return res;
if (foundGp && mDoneReadingHeaders) {
// We've found a packet with a granulepos, and we've loaded our metadata
// and initialized our decoder. Determine granulepos of buffered packets.
ReconstructTheoraGranulepos();
for (uint32_t i = 0; i < mUnstamped.Length(); ++i) {
- OggPacketPtr packet = Move(mUnstamped[i]);
+ OggPacketPtr packet = std::move(mUnstamped[i]);
#ifdef DEBUG
NS_ASSERTION(!IsHeader(packet.get()), "Don't try to recover header packet gp");
NS_ASSERTION(packet->granulepos != -1, "Packet must have gp by now");
#endif
- mPackets.Append(Move(packet));
+ mPackets.Append(std::move(packet));
}
mUnstamped.Clear();
}
return NS_OK;
}
// Returns 1 if the Theora info struct is decoding a media of Theora
// version (maj,min,sub) or later, otherwise returns 0.
@@ -680,17 +680,17 @@ VorbisState::~VorbisState()
vorbis_info_clear(&mVorbisInfo);
vorbis_comment_clear(&mComment);
}
bool
VorbisState::DecodeHeader(OggPacketPtr aPacket)
{
ogg_packet* packet = aPacket.get(); // Will be owned by mHeaders.
- mHeaders.Append(Move(aPacket));
+ mHeaders.Append(std::move(aPacket));
mPacketCount++;
int ret = vorbis_synthesis_headerin(&mVorbisInfo,
&mComment,
packet);
// We must determine when we've read the last header packet.
// vorbis_synthesis_headerin() does not tell us when it's read the last
// header, so we must keep track of the headers externally.
//
@@ -842,21 +842,21 @@ VorbisState::PageIn(ogg_page* aPage)
if (NS_FAILED(res)) {
return res;
}
if (foundGp && mDoneReadingHeaders) {
// We've found a packet with a granulepos, and we've loaded our metadata
// and initialized our decoder. Determine granulepos of buffered packets.
ReconstructVorbisGranulepos();
for (uint32_t i = 0; i < mUnstamped.Length(); ++i) {
- OggPacketPtr packet = Move(mUnstamped[i]);
+ OggPacketPtr packet = std::move(mUnstamped[i]);
AssertHasRecordedPacketSamples(packet.get());
NS_ASSERTION(!IsHeader(packet.get()), "Don't try to recover header packet gp");
NS_ASSERTION(packet->granulepos != -1, "Packet must have gp by now");
- mPackets.Append(Move(packet));
+ mPackets.Append(std::move(packet));
}
mUnstamped.Clear();
}
return NS_OK;
}
nsresult
VorbisState::ReconstructVorbisGranulepos()
@@ -1062,32 +1062,32 @@ OpusState::DecodeHeader(OggPacketPtr aPa
{
switch(mPacketCount++) {
// Parse the id header.
case 0:
mParser = new OpusParser;
if (!mParser->DecodeHeader(aPacket->packet, aPacket->bytes)) {
return false;
}
- mHeaders.Append(Move(aPacket));
+ mHeaders.Append(std::move(aPacket));
break;
// Parse the metadata header.
case 1:
if (!mParser->DecodeTags(aPacket->packet, aPacket->bytes)) {
return false;
}
break;
// We made it to the first data packet (which includes reconstructing
// timestamps for it in PageIn). Success!
default:
mDoneReadingHeaders = true;
// Put it back on the queue so we can decode it.
- mPackets.PushFront(Move(aPacket));
+ mPackets.PushFront(std::move(aPacket));
break;
}
return true;
}
/* Construct and return a tags hashmap from our internal array */
MetadataTags*
OpusState::GetTags()
@@ -1148,20 +1148,20 @@ OpusState::PageIn(ogg_page* aPage)
nsresult rv = PacketOutUntilGranulepos(haveGranulepos);
if (NS_FAILED(rv) || !haveGranulepos || mPacketCount < 2) {
return rv;
}
if (!ReconstructOpusGranulepos()) {
return NS_ERROR_FAILURE;
}
for (uint32_t i = 0; i < mUnstamped.Length(); i++) {
- OggPacketPtr packet = Move(mUnstamped[i]);
+ OggPacketPtr packet = std::move(mUnstamped[i]);
NS_ASSERTION(!IsHeader(packet.get()), "Don't try to play a header packet");
NS_ASSERTION(packet->granulepos != -1, "Packet should have a granulepos");
- mPackets.Append(Move(packet));
+ mPackets.Append(std::move(packet));
}
mUnstamped.Clear();
return NS_OK;
}
// Helper method to return the change in granule position due to an Opus packet
// (as distinct from the number of samples in the packet, which depends on the
// decoder rate). It should work with a multistream Opus file, and continue to
@@ -1368,20 +1368,20 @@ FlacState::PageIn(ogg_page* aPage)
if (NS_FAILED(res)) {
return res;
}
if (foundGp && mDoneReadingHeaders) {
// We've found a packet with a granulepos, and we've loaded our metadata
// and initialized our decoder. Determine granulepos of buffered packets.
ReconstructFlacGranulepos();
for (uint32_t i = 0; i < mUnstamped.Length(); ++i) {
- OggPacketPtr packet = Move(mUnstamped[i]);
+ OggPacketPtr packet = std::move(mUnstamped[i]);
NS_ASSERTION(!IsHeader(packet.get()), "Don't try to recover header packet gp");
NS_ASSERTION(packet->granulepos != -1, "Packet must have gp by now");
- mPackets.Append(Move(packet));
+ mPackets.Append(std::move(packet));
}
mUnstamped.Clear();
}
return NS_OK;
}
// Return a hash table with tag metadata.
MetadataTags*
--- a/dom/media/ogg/OggDemuxer.cpp
+++ b/dom/media/ogg/OggDemuxer.cpp
@@ -320,17 +320,17 @@ OggDemuxer::ReadHeaders(TrackInfo::Track
if (!packet) {
OGG_DEBUG("Ran out of header packets early; deactivating stream %" PRIu32, aState->mSerial);
aState->Deactivate();
return false;
}
// Local OggCodecState needs to decode headers in order to process
// packet granulepos -> time mappings, etc.
- if (!aState->DecodeHeader(Move(packet))) {
+ if (!aState->DecodeHeader(std::move(packet))) {
OGG_DEBUG("Failed to decode ogg header packet; deactivating stream %" PRIu32, aState->mSerial);
aState->Deactivate();
return false;
}
}
return aState->Init();
}
@@ -724,17 +724,17 @@ OggDemuxer::ReadOggChain(const media::Ti
if (chained) {
SetChained();
mInfo.mMediaSeekable = false;
mDecodedAudioDuration += aLastEndTime;
if (mTimedMetadataEvent) {
mTimedMetadataEvent->Notify(
TimedMetadata(mDecodedAudioDuration,
- Move(tags),
+ std::move(tags),
nsAutoPtr<MediaInfo>(new MediaInfo(mInfo))));
}
// Setup a new TrackInfo so that the MediaFormatReader will flush the
// current decoder.
mSharedAudioTrackInfo = new TrackInfoSharedPtr(mInfo.mAudio, ++sStreamSourceID);
return true;
}
@@ -1131,17 +1131,17 @@ OggDemuxer::SeekInternal(TrackInfo::Trac
if (foundKeyframe) {
tempPackets.Append(state->PacketOut());
} else {
// Discard video packets before the first keyframe.
Unused << state->PacketOut();
}
}
// Re-add all packet into the codec state in order.
- state->PushFront(Move(tempPackets));
+ state->PushFront(std::move(tempPackets));
return NS_OK;
}
OggDemuxer::IndexedSeekResult
OggDemuxer::RollbackIndexedSeek(TrackInfo::TrackType aType, int64_t aOffset)
{
if (mSkeletonState) {
@@ -1417,17 +1417,17 @@ OggTrackDemuxer::SkipToNextRandomAccessP
}
}
if (found) {
OGG_DEBUG("next sample: %f (parsed: %d)",
sample->mTime.ToSeconds(), parsed);
return SkipAccessPointPromise::CreateAndResolve(parsed, __func__);
} else {
SkipFailureHolder failure(NS_ERROR_DOM_MEDIA_END_OF_STREAM, parsed);
- return SkipAccessPointPromise::CreateAndReject(Move(failure), __func__);
+ return SkipAccessPointPromise::CreateAndReject(std::move(failure), __func__);
}
}
TimeIntervals
OggTrackDemuxer::GetBuffered()
{
return mParent->GetBuffered(mType);
}
--- a/dom/media/platforms/PDMFactory.cpp
+++ b/dom/media/platforms/PDMFactory.cpp
@@ -92,17 +92,17 @@ public:
kUnknown,
};
struct CheckResult
{
explicit CheckResult(Reason aReason,
MediaResult aResult = MediaResult(NS_OK))
: mReason(aReason),
- mMediaResult(mozilla::Move(aResult))
+ mMediaResult(std::move(aResult))
{
}
CheckResult(const CheckResult& aOther) = default;
CheckResult(CheckResult&& aOther) = default;
CheckResult& operator=(const CheckResult& aOther) = default;
CheckResult& operator=(CheckResult&& aOther) = default;
Reason mReason;
--- a/dom/media/platforms/agnostic/AOMDecoder.cpp
+++ b/dom/media/platforms/agnostic/AOMDecoder.cpp
@@ -308,19 +308,19 @@ AOMDecoder::ProcessDecode(MediaRawData*
if (!v) {
LOG(
"Image allocation error source %ux%u display %ux%u picture %ux%u",
img->d_w, img->d_h, mInfo.mDisplay.width, mInfo.mDisplay.height,
mInfo.mImage.width, mInfo.mImage.height);
return DecodePromise::CreateAndReject(
MediaResult(NS_ERROR_OUT_OF_MEMORY, __func__), __func__);
}
- results.AppendElement(Move(v));
+ results.AppendElement(std::move(v));
}
- return DecodePromise::CreateAndResolve(Move(results), __func__);
+ return DecodePromise::CreateAndResolve(std::move(results), __func__);
}
RefPtr<MediaDataDecoder::DecodePromise>
AOMDecoder::Decode(MediaRawData* aSample)
{
return InvokeAsync<MediaRawData*>(mTaskQueue, this, __func__,
&AOMDecoder::ProcessDecode, aSample);
}
--- a/dom/media/platforms/agnostic/BlankDecoderModule.cpp
+++ b/dom/media/platforms/agnostic/BlankDecoderModule.cpp
@@ -114,41 +114,41 @@ BlankAudioDataCreator::Create(MediaRawDa
samples[i * mChannelCount + c] = AudioDataValue(f);
}
mFrameSum++;
}
RefPtr<AudioData> data(new AudioData(aSample->mOffset,
aSample->mTime,
aSample->mDuration,
uint32_t(frames.value()),
- Move(samples),
+ std::move(samples),
mChannelCount,
mSampleRate));
return data.forget();
}
already_AddRefed<MediaDataDecoder>
BlankDecoderModule::CreateVideoDecoder(const CreateDecoderParams& aParams)
{
const VideoInfo& config = aParams.VideoConfig();
UniquePtr<DummyDataCreator> creator =
MakeUnique<BlankVideoDataCreator>(config.mDisplay.width, config.mDisplay.height, aParams.mImageContainer);
RefPtr<MediaDataDecoder> decoder = new DummyMediaDataDecoder(
- Move(creator), NS_LITERAL_CSTRING("blank media data decoder"), aParams);
+ std::move(creator), NS_LITERAL_CSTRING("blank media data decoder"), aParams);
return decoder.forget();
}
already_AddRefed<MediaDataDecoder>
BlankDecoderModule::CreateAudioDecoder(const CreateDecoderParams& aParams)
{
const AudioInfo& config = aParams.AudioConfig();
UniquePtr<DummyDataCreator> creator =
MakeUnique<BlankAudioDataCreator>(config.mChannels, config.mRate);
RefPtr<MediaDataDecoder> decoder = new DummyMediaDataDecoder(
- Move(creator), NS_LITERAL_CSTRING("blank media data decoder"), aParams);
+ std::move(creator), NS_LITERAL_CSTRING("blank media data decoder"), aParams);
return decoder.forget();
}
bool
BlankDecoderModule::SupportsMimeType(const nsACString& aMimeType,
DecoderDoctorDiagnostics* aDiagnostics) const
{
return true;
--- a/dom/media/platforms/agnostic/DummyMediaDataDecoder.cpp
+++ b/dom/media/platforms/agnostic/DummyMediaDataDecoder.cpp
@@ -11,17 +11,17 @@
namespace mozilla {
DummyDataCreator::~DummyDataCreator() {}
DummyMediaDataDecoder::DummyMediaDataDecoder(UniquePtr<DummyDataCreator>&& aCreator,
const nsACString& aDescription,
const CreateDecoderParams& aParams)
- : mCreator(Move(aCreator))
+ : mCreator(std::move(aCreator))
, mIsH264(MP4Decoder::IsH264(aParams.mConfig.mMimeType))
, mMaxRefFrames(
mIsH264
? H264::HasSPS(aParams.VideoConfig().mExtraData)
? H264::ComputeMaxRefFrames(aParams.VideoConfig().mExtraData)
: 16
: 0)
, mType(aParams.mConfig.GetType())
--- a/dom/media/platforms/agnostic/NullDecoderModule.cpp
+++ b/dom/media/platforms/agnostic/NullDecoderModule.cpp
@@ -33,17 +33,17 @@ class NullDecoderModule : public Platfor
public:
// Decode thread.
already_AddRefed<MediaDataDecoder> CreateVideoDecoder(
const CreateDecoderParams& aParams) override
{
UniquePtr<DummyDataCreator> creator = MakeUnique<NullVideoDataCreator>();
RefPtr<MediaDataDecoder> decoder = new DummyMediaDataDecoder(
- Move(creator), NS_LITERAL_CSTRING("null media data decoder"), aParams);
+ std::move(creator), NS_LITERAL_CSTRING("null media data decoder"), aParams);
return decoder.forget();
}
// Decode thread.
already_AddRefed<MediaDataDecoder> CreateAudioDecoder(
const CreateDecoderParams& aParams) override
{
MOZ_ASSERT(false, "Audio decoders are unsupported.");
--- a/dom/media/platforms/agnostic/OpusDecoder.cpp
+++ b/dom/media/platforms/agnostic/OpusDecoder.cpp
@@ -336,17 +336,17 @@ OpusDataDecoder::ProcessDecode(MediaRawD
mFrames += frames;
return DecodePromise::CreateAndResolve(
DecodedData{ new AudioData(aSample->mOffset,
time,
duration,
frames,
- Move(buffer),
+ std::move(buffer),
mOpusParser->mChannels,
mOpusParser->mRate,
mChannelMap) },
__func__);
}
RefPtr<MediaDataDecoder::DecodePromise>
OpusDataDecoder::Drain()
--- a/dom/media/platforms/agnostic/VPXDecoder.cpp
+++ b/dom/media/platforms/agnostic/VPXDecoder.cpp
@@ -228,19 +228,19 @@ VPXDecoder::ProcessDecode(MediaRawData*
if (!v) {
LOG(
"Image allocation error source %ux%u display %ux%u picture %ux%u",
img->d_w, img->d_h, mInfo.mDisplay.width, mInfo.mDisplay.height,
mInfo.mImage.width, mInfo.mImage.height);
return DecodePromise::CreateAndReject(
MediaResult(NS_ERROR_OUT_OF_MEMORY, __func__), __func__);
}
- results.AppendElement(Move(v));
+ results.AppendElement(std::move(v));
}
- return DecodePromise::CreateAndResolve(Move(results), __func__);
+ return DecodePromise::CreateAndResolve(std::move(results), __func__);
}
RefPtr<MediaDataDecoder::DecodePromise>
VPXDecoder::Decode(MediaRawData* aSample)
{
return InvokeAsync<MediaRawData*>(mTaskQueue, this, __func__,
&VPXDecoder::ProcessDecode, aSample);
}
--- a/dom/media/platforms/agnostic/VorbisDecoder.cpp
+++ b/dom/media/platforms/agnostic/VorbisDecoder.cpp
@@ -236,18 +236,18 @@ VorbisDataDecoder::ProcessDecode(MediaRa
const AudioConfig::ChannelLayout layout =
AudioConfig::ChannelLayout(channels, VorbisLayout(channels));
AudioConfig in(layout, channels, rate);
AudioConfig out(
AudioConfig::ChannelLayout::SMPTEDefault(layout), channels, rate);
mAudioConverter = MakeUnique<AudioConverter>(in, out);
}
MOZ_ASSERT(mAudioConverter->CanWorkInPlace());
- AudioSampleBuffer data(Move(buffer));
- data = mAudioConverter->Process(Move(data));
+ AudioSampleBuffer data(std::move(buffer));
+ data = mAudioConverter->Process(std::move(data));
results.AppendElement(
new AudioData(aOffset,
time,
duration,
frames,
data.Forget(),
channels,
@@ -259,17 +259,17 @@ VorbisDataDecoder::ProcessDecode(MediaRa
return DecodePromise::CreateAndReject(
MediaResult(NS_ERROR_DOM_MEDIA_DECODE_ERR,
RESULT_DETAIL("vorbis_synthesis_read:%d", err)),
__func__);
}
frames = vorbis_synthesis_pcmout(&mVorbisDsp, &pcm);
}
- return DecodePromise::CreateAndResolve(Move(results), __func__);
+ return DecodePromise::CreateAndResolve(std::move(results), __func__);
}
RefPtr<MediaDataDecoder::DecodePromise>
VorbisDataDecoder::Drain()
{
return InvokeAsync(mTaskQueue, __func__, [] {
return DecodePromise::CreateAndResolve(DecodedData(), __func__);
});
--- a/dom/media/platforms/agnostic/WAVDecoder.cpp
+++ b/dom/media/platforms/agnostic/WAVDecoder.cpp
@@ -136,17 +136,17 @@ WaveDataDecoder::ProcessDecode(MediaRawD
}
}
}
auto duration = FramesToTimeUnit(frames, mInfo.mRate);
return DecodePromise::CreateAndResolve(
DecodedData{ new AudioData(aOffset, aSample->mTime, duration, frames,
- Move(buffer), mInfo.mChannels, mInfo.mRate) },
+ std::move(buffer), mInfo.mChannels, mInfo.mRate) },
__func__);
}
RefPtr<MediaDataDecoder::DecodePromise>
WaveDataDecoder::Drain()
{
return InvokeAsync(mTaskQueue, __func__, [] {
return DecodePromise::CreateAndResolve(DecodedData(), __func__);
--- a/dom/media/platforms/agnostic/eme/EMEDecoderModule.cpp
+++ b/dom/media/platforms/agnostic/eme/EMEDecoderModule.cpp
@@ -83,17 +83,17 @@ public:
MediaEventProducer<TrackInfo::TrackType>* aOnWaitingForKey,
UniquePtr<ADTSSampleConverter> aConverter = nullptr)
: mDecoder(aDecoder)
, mTaskQueue(aDecodeTaskQueue)
, mProxy(aProxy)
, mSamplesWaitingForKey(
new SamplesWaitingForKey(mProxy, aType, aOnWaitingForKey))
, mThroughputLimiter(aDecodeTaskQueue)
- , mADTSSampleConverter(Move(aConverter))
+ , mADTSSampleConverter(std::move(aConverter))
, mIsShutdown(false)
{
DDLINKCHILD("decoder", mDecoder.get());
}
RefPtr<InitPromise> Init() override
{
MOZ_ASSERT(!mIsShutdown);
@@ -299,31 +299,31 @@ private:
UniquePtr<ADTSSampleConverter> mADTSSampleConverter;
bool mIsShutdown;
};
EMEMediaDataDecoderProxy::EMEMediaDataDecoderProxy(
already_AddRefed<AbstractThread> aProxyThread,
CDMProxy* aProxy,
const CreateDecoderParams& aParams)
- : MediaDataDecoderProxy(Move(aProxyThread))
+ : MediaDataDecoderProxy(std::move(aProxyThread))
, mTaskQueue(AbstractThread::GetCurrent()->AsTaskQueue())
, mSamplesWaitingForKey(
new SamplesWaitingForKey(aProxy,
aParams.mType,
aParams.mOnWaitingForKeyEvent))
, mProxy(aProxy)
{
}
EMEMediaDataDecoderProxy::EMEMediaDataDecoderProxy(
const CreateDecoderParams& aParams,
already_AddRefed<MediaDataDecoder> aProxyDecoder,
CDMProxy* aProxy)
- : MediaDataDecoderProxy(Move(aProxyDecoder))
+ : MediaDataDecoderProxy(std::move(aProxyDecoder))
, mTaskQueue(AbstractThread::GetCurrent()->AsTaskQueue())
, mSamplesWaitingForKey(
new SamplesWaitingForKey(aProxy,
aParams.mType,
aParams.mOnWaitingForKeyEvent))
, mProxy(aProxy)
{
}
@@ -464,17 +464,17 @@ EMEDecoderModule::CreateAudioDecoder(con
}
RefPtr<MediaDataDecoder> emeDecoder(
new EMEDecryptor(decoder,
mProxy,
AbstractThread::GetCurrent()->AsTaskQueue(),
aParams.mType,
aParams.mOnWaitingForKeyEvent,
- Move(converter)));
+ std::move(converter)));
return emeDecoder.forget();
}
bool
EMEDecoderModule::SupportsMimeType(const nsACString& aMimeType,
DecoderDoctorDiagnostics* aDiagnostics) const
{
Maybe<nsCString> gmp;
--- a/dom/media/platforms/agnostic/eme/SamplesWaitingForKey.cpp
+++ b/dom/media/platforms/agnostic/eme/SamplesWaitingForKey.cpp
@@ -39,17 +39,17 @@ SamplesWaitingForKey::WaitIfKeyNotUsable
if (caps->IsKeyUsable(keyid)) {
return WaitForKeyPromise::CreateAndResolve(aSample, __func__);
}
SampleEntry entry;
entry.mSample = aSample;
RefPtr<WaitForKeyPromise> p = entry.mPromise.Ensure(__func__);
{
MutexAutoLock lock(mMutex);
- mSamples.AppendElement(Move(entry));
+ mSamples.AppendElement(std::move(entry));
}
if (mOnWaitingForKeyEvent) {
mOnWaitingForKeyEvent->Notify(mType);
}
caps->NotifyWhenKeyIdUsable(aSample->mCrypto.mKeyId, this);
return p;
}
--- a/dom/media/platforms/agnostic/gmp/GMPVideoDecoder.cpp
+++ b/dom/media/platforms/agnostic/gmp/GMPVideoDecoder.cpp
@@ -70,17 +70,17 @@ GMPVideoDecoder::Decoded(GMPVideoi420Fra
media::TimeUnit::FromMicroseconds(decodedFrame->Timestamp()),
media::TimeUnit::FromMicroseconds(decodedFrame->Duration()),
b,
false,
media::TimeUnit::FromMicroseconds(-1),
pictureRegion);
RefPtr<GMPVideoDecoder> self = this;
if (v) {
- mDecodedData.AppendElement(Move(v));
+ mDecodedData.AppendElement(std::move(v));
} else {
mDecodedData.Clear();
mDecodePromise.RejectIfExists(
MediaResult(NS_ERROR_OUT_OF_MEMORY,
RESULT_DETAIL("CallBack::CreateAndCopyData")),
__func__);
}
}
@@ -298,17 +298,17 @@ GMPVideoDecoder::Init()
RefPtr<InitPromise> promise(mInitPromise.Ensure(__func__));
nsTArray<nsCString> tags;
InitTags(tags);
UniquePtr<GetGMPVideoDecoderCallback> callback(new GMPInitDoneCallback(this));
if (NS_FAILED(mMPS->GetDecryptingGMPVideoDecoder(mCrashHelper,
&tags,
GetNodeId(),
- Move(callback),
+ std::move(callback),
DecryptorId()))) {
mInitPromise.Reject(NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
}
return promise;
}
RefPtr<MediaDataDecoder::DecodePromise>
@@ -330,17 +330,17 @@ GMPVideoDecoder::Decode(MediaRawData* aS
if (!frame) {
return DecodePromise::CreateAndReject(
MediaResult(NS_ERROR_OUT_OF_MEMORY,
RESULT_DETAIL("CreateFrame returned null")),
__func__);
}
RefPtr<DecodePromise> p = mDecodePromise.Ensure(__func__);
nsTArray<uint8_t> info; // No codec specific per-frame info to pass.
- nsresult rv = mGMP->Decode(Move(frame), false, info, 0);
+ nsresult rv = mGMP->Decode(std::move(frame), false, info, 0);
if (NS_FAILED(rv)) {
mDecodePromise.Reject(MediaResult(NS_ERROR_DOM_MEDIA_DECODE_ERR,
RESULT_DETAIL("mGMP->Decode:%" PRIx32,
static_cast<uint32_t>(rv))),
__func__);
}
return p;
}
--- a/dom/media/platforms/android/RemoteDataDecoder.cpp
+++ b/dom/media/platforms/android/RemoteDataDecoder.cpp
@@ -141,18 +141,18 @@ public:
RefPtr<VideoData> v = VideoData::CreateFromImage(
inputInfo.mDisplaySize, offset,
TimeUnit::FromMicroseconds(presentationTimeUs),
TimeUnit::FromMicroseconds(inputInfo.mDurationUs),
img, !!(flags & MediaCodec::BUFFER_FLAG_SYNC_FRAME),
TimeUnit::FromMicroseconds(presentationTimeUs));
- v->SetListener(Move(releaseSample));
- mDecoder->UpdateOutputStatus(Move(v));
+ v->SetListener(std::move(releaseSample));
+ mDecoder->UpdateOutputStatus(std::move(v));
}
if (isEOS) {
mDecoder->DrainComplete();
}
}
void HandleError(const MediaResult& aError) override
@@ -361,19 +361,19 @@ private:
jni::ByteBuffer::LocalRef dest =
jni::ByteBuffer::New(audio.get(), size);
aSample->WriteToByteBuffer(dest);
RefPtr<AudioData> data = new AudioData(
0, TimeUnit::FromMicroseconds(presentationTimeUs),
FramesToTimeUnit(numFrames, mOutputSampleRate), numFrames,
- Move(audio), mOutputChannels, mOutputSampleRate);
+ std::move(audio), mOutputChannels, mOutputSampleRate);
- mDecoder->UpdateOutputStatus(Move(data));
+ mDecoder->UpdateOutputStatus(std::move(data));
}
if ((flags & MediaCodec::BUFFER_FLAG_END_OF_STREAM) != 0) {
mDecoder->DrainComplete();
}
}
void HandleOutputFormatChanged(MediaFormat::Param aFormat) override
@@ -666,27 +666,27 @@ void
RemoteDataDecoder::UpdateOutputStatus(RefPtr<MediaData>&& aSample)
{
if (!mTaskQueue->IsCurrentThreadIn()) {
nsresult rv =
mTaskQueue->Dispatch(
NewRunnableMethod<const RefPtr<MediaData>>("RemoteDataDecoder::UpdateOutputStatus",
this,
&RemoteDataDecoder::UpdateOutputStatus,
- Move(aSample)));
+ std::move(aSample)));
MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));
Unused << rv;
return;
}
AssertOnTaskQueue();
if (mShutdown) {
return;
}
if (IsUsefulData(aSample)) {
- mDecodedData.AppendElement(Move(aSample));
+ mDecodedData.AppendElement(std::move(aSample));
}
ReturnDecodedData();
}
void
RemoteDataDecoder::ReturnDecodedData()
{
AssertOnTaskQueue();
--- a/dom/media/platforms/apple/AppleATDecoder.cpp
+++ b/dom/media/platforms/apple/AppleATDecoder.cpp
@@ -217,17 +217,17 @@ AppleATDecoder::ProcessDecode(MediaRawDa
if (NS_FAILED(rv)) {
mErrored = true;
return DecodePromise::CreateAndReject(rv, __func__);
}
}
mQueuedSamples.Clear();
}
- return DecodePromise::CreateAndResolve(Move(mDecodedSamples), __func__);
+ return DecodePromise::CreateAndResolve(std::move(mDecodedSamples), __func__);
}
MediaResult
AppleATDecoder::DecodeSample(MediaRawData* aSample)
{
MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
// Array containing the queued decoded audio frames, about to be output.
@@ -316,31 +316,31 @@ AppleATDecoder::DecodeSample(MediaRawDat
if (mChannelLayout && !mAudioConverter) {
AudioConfig in(*mChannelLayout, channels, rate);
AudioConfig out(AudioConfig::ChannelLayout::SMPTEDefault(*mChannelLayout),
channels, rate);
mAudioConverter = MakeUnique<AudioConverter>(in, out);
}
if (mAudioConverter && mChannelLayout && mChannelLayout->IsValid()) {
MOZ_ASSERT(mAudioConverter->CanWorkInPlace());
- data = mAudioConverter->Process(Move(data));
+ data = mAudioConverter->Process(std::move(data));
}
RefPtr<AudioData> audio =
new AudioData(aSample->mOffset,
aSample->mTime,
duration,
numFrames,
data.Forget(),
channels,
rate,
mChannelLayout && mChannelLayout->IsValid()
? mChannelLayout->Map()
: AudioConfig::ChannelLayout::UNKNOWN_MAP);
- mDecodedSamples.AppendElement(Move(audio));
+ mDecodedSamples.AppendElement(std::move(audio));
return NS_OK;
}
MediaResult
AppleATDecoder::GetInputAudioDescription(AudioStreamBasicDescription& aDesc,
const nsTArray<uint8_t>& aExtraData)
{
MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
--- a/dom/media/platforms/apple/AppleVTDecoder.cpp
+++ b/dom/media/platforms/apple/AppleVTDecoder.cpp
@@ -252,19 +252,19 @@ AppleVTDecoder::ProcessDrain()
AssertOnTaskQueueThread();
nsresult rv = WaitForAsynchronousFrames();
if (NS_FAILED(rv)) {
LOG("AppleVTDecoder::Drain failed waiting for platform decoder");
}
MonitorAutoLock mon(mMonitor);
DecodedData samples;
while (!mReorderQueue.IsEmpty()) {
- samples.AppendElement(Move(mReorderQueue.Pop()));
+ samples.AppendElement(std::move(mReorderQueue.Pop()));
}
- return DecodePromise::CreateAndResolve(Move(samples), __func__);
+ return DecodePromise::CreateAndResolve(std::move(samples), __func__);
}
AppleVTDecoder::AppleFrameRef*
AppleVTDecoder::CreateAppleFrameRef(const MediaRawData* aSample)
{
MOZ_ASSERT(aSample);
return new AppleFrameRef(*aSample);
}
@@ -457,17 +457,17 @@ AppleVTDecoder::OutputFrame(CVPixelBuffe
// Frames come out in DTS order but we need to output them
// in composition order.
MonitorAutoLock mon(mMonitor);
mReorderQueue.Push(data);
DecodedData results;
while (mReorderQueue.Length() > mMaxRefFrames) {
results.AppendElement(mReorderQueue.Pop());
}
- mPromise.Resolve(Move(results), __func__);
+ mPromise.Resolve(std::move(results), __func__);
LOG("%llu decoded frames queued",
static_cast<unsigned long long>(mReorderQueue.Length()));
}
nsresult
AppleVTDecoder::WaitForAsynchronousFrames()
{
--- a/dom/media/platforms/ffmpeg/FFmpegAudioDecoder.cpp
+++ b/dom/media/platforms/ffmpeg/FFmpegAudioDecoder.cpp
@@ -249,17 +249,17 @@ FFmpegAudioDecoder<LIBAV_VER>::DoDecode(
NS_ERROR_DOM_MEDIA_OVERFLOW_ERR,
RESULT_DETAIL("Invalid count of accumulated audio samples"));
}
aResults.AppendElement(new AudioData(samplePosition,
pts,
duration,
mFrame->nb_samples,
- Move(audio),
+ std::move(audio),
numChannels,
samplingRate,
mCodecContext->channel_layout));
pts = newpts;
if (aGotFrame) {
*aGotFrame = true;
--- a/dom/media/platforms/ffmpeg/FFmpegDataDecoder.cpp
+++ b/dom/media/platforms/ffmpeg/FFmpegDataDecoder.cpp
@@ -129,17 +129,17 @@ RefPtr<MediaDataDecoder::DecodePromise>
FFmpegDataDecoder<LIBAV_VER>::ProcessDecode(MediaRawData* aSample)
{
bool gotFrame = false;
DecodedData results;
MediaResult rv = DoDecode(aSample, &gotFrame, results);
if (NS_FAILED(rv)) {
return DecodePromise::CreateAndReject(rv, __func__);
}
- return DecodePromise::CreateAndResolve(Move(results), __func__);
+ return DecodePromise::CreateAndResolve(std::move(results), __func__);
}
MediaResult
FFmpegDataDecoder<LIBAV_VER>::DoDecode(MediaRawData* aSample, bool* aGotFrame,
MediaDataDecoder::DecodedData& aResults)
{
uint8_t* inputData = const_cast<uint8_t*>(aSample->Data());
size_t inputSize = aSample->Size();
@@ -197,17 +197,17 @@ FFmpegDataDecoder<LIBAV_VER>::ProcessDra
{
RefPtr<MediaRawData> empty(new MediaRawData());
empty->mTimecode = mLastInputDts;
bool gotFrame = false;
DecodedData results;
while (NS_SUCCEEDED(DoDecode(empty, &gotFrame, results)) &&
gotFrame) {
}
- return DecodePromise::CreateAndResolve(Move(results), __func__);
+ return DecodePromise::CreateAndResolve(std::move(results), __func__);
}
RefPtr<MediaDataDecoder::FlushPromise>
FFmpegDataDecoder<LIBAV_VER>::ProcessFlush()
{
MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
if (mCodecContext) {
mLib->avcodec_flush_buffers(mCodecContext);
--- a/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp
+++ b/dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp
@@ -345,17 +345,17 @@ FFmpegVideoDecoder<LIBAV_VER>::DoDecode(
mInfo.ScaledImageRect(mFrame->width,
mFrame->height),
mImageAllocator);
if (!v) {
return MediaResult(NS_ERROR_OUT_OF_MEMORY,
RESULT_DETAIL("image allocation error"));
}
- aResults.AppendElement(Move(v));
+ aResults.AppendElement(std::move(v));
if (aGotFrame) {
*aGotFrame = true;
}
return NS_OK;
}
RefPtr<MediaDataDecoder::FlushPromise>
FFmpegVideoDecoder<LIBAV_VER>::ProcessFlush()
--- a/dom/media/platforms/omx/OmxDataDecoder.cpp
+++ b/dom/media/platforms/omx/OmxDataDecoder.cpp
@@ -177,17 +177,17 @@ OmxDataDecoder::Decode(MediaRawData* aSa
{
LOG("sample %p", aSample);
MOZ_ASSERT(mInitPromise.IsEmpty());
RefPtr<OmxDataDecoder> self = this;
RefPtr<MediaRawData> sample = aSample;
return InvokeAsync(mOmxTaskQueue, __func__, [self, this, sample]() {
RefPtr<DecodePromise> p = mDecodePromise.Ensure(__func__);
- mMediaRawDatas.AppendElement(Move(sample));
+ mMediaRawDatas.AppendElement(std::move(sample));
// Start to fill/empty buffers.
if (mOmxState == OMX_StateIdle ||
mOmxState == OMX_StateExecuting) {
FillAndEmptyBuffers();
}
return p;
});
@@ -362,17 +362,17 @@ OmxDataDecoder::Output(BufferData* aData
[buffer] () {
MOZ_RELEASE_ASSERT(buffer->mStatus == BufferData::BufferStatus::OMX_CLIENT_OUTPUT);
buffer->mStatus = BufferData::BufferStatus::FREE;
});
} else {
aData->mStatus = BufferData::BufferStatus::FREE;
}
- mDecodedData.AppendElement(Move(data));
+ mDecodedData.AppendElement(std::move(data));
}
void
OmxDataDecoder::FillBufferFailure(OmxBufferFailureHolder aFailureHolder)
{
NotifyError(aFailureHolder.mError, __func__);
}
--- a/dom/media/platforms/omx/OmxPlatformLayer.cpp
+++ b/dom/media/platforms/omx/OmxPlatformLayer.cpp
@@ -168,17 +168,17 @@ ConfigForMime(const nsACString& aMimeTyp
aMimeType.EqualsLiteral("audio/mpeg")) {
conf.reset(new OmxMp3Config());
} else if (aMimeType.EqualsLiteral("audio/3gpp")) {
conf.reset(new OmxAmrConfig<OmxAmrSampleRate::kNarrowBand>());
} else if (aMimeType.EqualsLiteral("audio/amr-wb")) {
conf.reset(new OmxAmrConfig<OmxAmrSampleRate::kWideBand>());
}
}
- return Move(conf);
+ return std::move(conf);
}
// There should be a better way to calculate it.
#define MIN_VIDEO_INPUT_BUFFER_SIZE 64 * 1024
class OmxCommonVideoConfig : public OmxVideoConfig
{
public:
@@ -226,17 +226,17 @@ template<>
UniquePtr<OmxVideoConfig>
ConfigForMime(const nsACString& aMimeType)
{
UniquePtr<OmxVideoConfig> conf;
if (OmxPlatformLayer::SupportsMimeType(aMimeType)) {
conf.reset(new OmxCommonVideoConfig());
}
- return Move(conf);
+ return std::move(conf);
}
OMX_ERRORTYPE
OmxPlatformLayer::Config()
{
MOZ_ASSERT(mInfo);
OMX_PORT_PARAM_TYPE portParam;
--- a/dom/media/platforms/omx/OmxPromiseLayer.cpp
+++ b/dom/media/platforms/omx/OmxPromiseLayer.cpp
@@ -69,17 +69,17 @@ OmxPromiseLayer::FillBuffer(BufferData*
LOG("buffer %p", aData->mBuffer);
RefPtr<OmxBufferPromise> p = aData->mPromise.Ensure(__func__);
OMX_ERRORTYPE err = mPlatformLayer->FillThisBuffer(aData);
if (err != OMX_ErrorNone) {
OmxBufferFailureHolder failure(err, aData);
- aData->mPromise.Reject(Move(failure), __func__);
+ aData->mPromise.Reject(std::move(failure), __func__);
} else {
aData->mStatus = BufferData::BufferStatus::OMX_COMPONENT;
GetBufferHolders(OMX_DirOutput)->AppendElement(aData);
}
return p;
}
@@ -90,20 +90,20 @@ OmxPromiseLayer::EmptyBuffer(BufferData*
LOG("buffer %p, size %lu", aData->mBuffer, aData->mBuffer->nFilledLen);
RefPtr<OmxBufferPromise> p = aData->mPromise.Ensure(__func__);
OMX_ERRORTYPE err = mPlatformLayer->EmptyThisBuffer(aData);
if (err != OMX_ErrorNone) {
OmxBufferFailureHolder failure(err, aData);
- aData->mPromise.Reject(Move(failure), __func__);
+ aData->mPromise.Reject(std::move(failure), __func__);
} else {
if (aData->mRawData) {
- mRawDatas.AppendElement(Move(aData->mRawData));
+ mRawDatas.AppendElement(std::move(aData->mRawData));
}
aData->mStatus = BufferData::BufferStatus::OMX_COMPONENT;
GetBufferHolders(OMX_DirInput)->AppendElement(aData);
}
return p;
}
--- a/dom/media/platforms/wmf/WMFAudioMFTManager.cpp
+++ b/dom/media/platforms/wmf/WMFAudioMFTManager.cpp
@@ -337,17 +337,17 @@ WMFAudioMFTManager::Output(int64_t aStre
media::TimeUnit duration = FramesToTimeUnit(numFrames, mAudioRate);
NS_ENSURE_TRUE(duration.IsValid(), E_FAIL);
aOutData = new AudioData(aStreamOffset,
timestamp,
duration,
numFrames,
- Move(audioData),
+ std::move(audioData),
mAudioChannels,
mAudioRate,
mChannelsMap);
#ifdef LOG_SAMPLE_DECODE
LOG("Decoded audio sample! timestamp=%lld duration=%lld currentLength=%u",
timestamp.ToMicroseconds(), duration.ToMicroseconds(), currentLength);
#endif
--- a/dom/media/platforms/wmf/WMFMediaDataDecoder.cpp
+++ b/dom/media/platforms/wmf/WMFMediaDataDecoder.cpp
@@ -143,30 +143,30 @@ WMFMediaDataDecoder::ProcessDecode(Media
return ProcessError(hr, "MFTManager::Input");
}
mDrainStatus = DrainStatus::DRAINABLE;
mLastStreamOffset = aSample->mOffset;
hr = ProcessOutput(results);
if (SUCCEEDED(hr) || hr == MF_E_TRANSFORM_NEED_MORE_INPUT) {
- return DecodePromise::CreateAndResolve(Move(results), __func__);
+ return DecodePromise::CreateAndResolve(std::move(results), __func__);
}
return ProcessError(hr, "MFTManager::Output(2)");
}
HRESULT
WMFMediaDataDecoder::ProcessOutput(DecodedData& aResults)
{
RefPtr<MediaData> output;
HRESULT hr = S_OK;
while (SUCCEEDED(hr = mMFTManager->Output(mLastStreamOffset, output))) {
MOZ_ASSERT(output.get(), "Upon success, we must receive an output");
mHasSuccessfulOutput = true;
- aResults.AppendElement(Move(output));
+ aResults.AppendElement(std::move(output));
if (mDrainStatus == DrainStatus::DRAINING) {
break;
}
}
return hr;
}
RefPtr<MediaDataDecoder::FlushPromise>
@@ -203,17 +203,17 @@ WMFMediaDataDecoder::ProcessDrain()
// Then extract all available output.
DecodedData results;
HRESULT hr = ProcessOutput(results);
if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT) {
mDrainStatus = DrainStatus::DRAINED;
}
if (SUCCEEDED(hr) || hr == MF_E_TRANSFORM_NEED_MORE_INPUT) {
- return DecodePromise::CreateAndResolve(Move(results), __func__);
+ return DecodePromise::CreateAndResolve(std::move(results), __func__);
}
return ProcessError(hr, "MFTManager::Output");
}
RefPtr<MediaDataDecoder::DecodePromise>
WMFMediaDataDecoder::Drain()
{
MOZ_DIAGNOSTIC_ASSERT(!mIsShutDown);
--- a/dom/media/systemservices/CamerasParent.cpp
+++ b/dom/media/systemservices/CamerasParent.cpp
@@ -149,26 +149,26 @@ public:
CaptureEngine aEngine,
uint32_t aStreamId,
ShmemBuffer aBuffer,
VideoFrameProperties& aProperties)
: Runnable("camera::DeliverFrameRunnable")
, mParent(aParent)
, mCapEngine(aEngine)
, mStreamId(aStreamId)
- , mBuffer(Move(aBuffer))
+ , mBuffer(std::move(aBuffer))
, mProperties(aProperties){};
NS_IMETHOD Run() override {
if (mParent->IsShuttingDown()) {
// Communication channel is being torn down
mResult = 0;
return NS_OK;
}
- if (!mParent->DeliverFrameOverIPC(mCapEngine, mStreamId, Move(mBuffer),
+ if (!mParent->DeliverFrameOverIPC(mCapEngine, mStreamId, std::move(mBuffer),
mAlternateBuffer.get(), mProperties)) {
mResult = -1;
} else {
mResult = 0;
}
return NS_OK;
}
@@ -332,17 +332,17 @@ CallbackHelper::OnFrame(const webrtc::Vi
LOG(("Correctly sized Video shmem not available in DeliverFrame"));
// We will do the copy into a(n extra) temporary buffer inside
// the DeliverFrameRunnable constructor.
} else {
// Shared memory buffers of the right size are available, do the copy here.
VideoFrameUtils::CopyVideoFrameBuffers(shMemBuffer.GetBytes(),
properties.bufferSize(), aVideoFrame);
runnable = new DeliverFrameRunnable(mParent, mCapEngine, mStreamId,
- Move(shMemBuffer), properties);
+ std::move(shMemBuffer), properties);
}
if (!runnable) {
runnable = new DeliverFrameRunnable(mParent, mCapEngine, mStreamId,
aVideoFrame, properties);
}
MOZ_ASSERT(mParent);
nsIEventTarget* target = mParent->GetBackgroundEventTarget();
MOZ_ASSERT(target != nullptr);
@@ -388,17 +388,17 @@ CamerasParent::SetupEngine(CaptureEngine
break;
default:
LOG(("Invalid webrtc Video engine"));
MOZ_CRASH();
break;
}
config->Set<webrtc::CaptureDeviceInfo>(captureDeviceInfo.release());
- engine = VideoEngine::Create(Move(config));
+ engine = VideoEngine::Create(std::move(config));
if (!engine) {
LOG(("VideoEngine::Create failed"));
return false;
}
}
if (aCapEngine == CameraEngine && !mCameraObserver) {
--- a/dom/media/systemservices/MediaTaskUtils.h
+++ b/dom/media/systemservices/MediaTaskUtils.h
@@ -21,17 +21,17 @@ namespace media {
*/
template<typename OnRunType>
class LambdaTask : public Runnable
{
public:
explicit LambdaTask(OnRunType&& aOnRun)
: Runnable("media::LambdaTask")
- , mOnRun(Move(aOnRun))
+ , mOnRun(std::move(aOnRun))
{
}
private:
NS_IMETHOD
Run() override
{
mOnRun();
--- a/dom/media/systemservices/MediaUtils.h
+++ b/dom/media/systemservices/MediaUtils.h
@@ -86,17 +86,17 @@ public:
template<typename OnSuccessType, typename OnFailureType>
void Then(OnSuccessType&& aOnSuccess, OnFailureType&& aOnFailure)
{
class Functors : public FunctorsBase
{
public:
Functors(OnSuccessType&& aOnSuccessRef, OnFailureType&& aOnFailureRef)
- : mOnSuccess(Move(aOnSuccessRef)), mOnFailure(Move(aOnFailureRef)) {}
+ : mOnSuccess(std::move(aOnSuccessRef)), mOnFailure(std::move(aOnFailureRef)) {}
void Succeed(ValueType& result)
{
mOnSuccess(result);
}
void Fail(ErrorType& error)
{
mOnFailure(error);
@@ -193,17 +193,17 @@ private:
*/
template<typename OnRunType>
class LambdaRunnable : public Runnable
{
public:
explicit LambdaRunnable(OnRunType&& aOnRun)
: Runnable("media::LambdaRunnable")
- , mOnRun(Move(aOnRun))
+ , mOnRun(std::move(aOnRun))
{
}
private:
NS_IMETHODIMP
Run() override
{
return mOnRun();
@@ -434,17 +434,17 @@ template<typename ResolveValueType,
void
Await(
already_AddRefed<nsIEventTarget> aPool,
RefPtr<MozPromise<ResolveValueType, RejectValueType, true>> aPromise,
ResolveFunction&& aResolveFunction,
RejectFunction&& aRejectFunction)
{
RefPtr<AutoTaskQueue> taskQueue =
- new AutoTaskQueue(Move(aPool), "MozPromiseAwait");
+ new AutoTaskQueue(std::move(aPool), "MozPromiseAwait");
// We can't use a Monitor allocated on the stack (see bug 1426067)
Monitor& mon = taskQueue->Monitor();
bool done = false;
aPromise->Then(taskQueue,
__func__,
[&](ResolveValueType&& aResolveValue) {
MonitorAutoLock lock(mon);
@@ -467,32 +467,32 @@ Await(
template<typename ResolveValueType, typename RejectValueType, bool Excl>
typename MozPromise<ResolveValueType, RejectValueType, Excl>::
ResolveOrRejectValue
Await(already_AddRefed<nsIEventTarget> aPool,
RefPtr<MozPromise<ResolveValueType, RejectValueType, Excl>> aPromise)
{
RefPtr<AutoTaskQueue> taskQueue =
- new AutoTaskQueue(Move(aPool), "MozPromiseAwait");
+ new AutoTaskQueue(std::move(aPool), "MozPromiseAwait");
// We can't use a Monitor allocated on the stack (see bug 1426067)
Monitor& mon = taskQueue->Monitor();
bool done = false;
typename MozPromise<ResolveValueType, RejectValueType, Excl>::ResolveOrRejectValue val;
aPromise->Then(taskQueue,
__func__,
[&](ResolveValueType aResolveValue) {
- val.SetResolve(Move(aResolveValue));
+ val.SetResolve(std::move(aResolveValue));
MonitorAutoLock lock(mon);
done = true;
mon.Notify();
},
[&](RejectValueType aRejectValue) {
- val.SetReject(Move(aRejectValue));
+ val.SetReject(std::move(aRejectValue));
MonitorAutoLock lock(mon);
done = true;
mon.Notify();
});
MonitorAutoLock lock(mon);
while (!done) {
mon.Wait();
@@ -516,17 +516,17 @@ AwaitAll(already_AddRefed<nsIEventTarget
ResolveFunction&& aResolveFunction,
RejectFunction&& aRejectFunction)
{
typedef MozPromise<ResolveValueType, RejectValueType, true> Promise;
RefPtr<nsIEventTarget> pool = aPool;
RefPtr<AutoTaskQueue> taskQueue =
new AutoTaskQueue(do_AddRef(pool), "MozPromiseAwaitAll");
RefPtr<typename Promise::AllPromiseType> p = Promise::All(taskQueue, aPromises);
- Await(pool.forget(), p, Move(aResolveFunction), Move(aRejectFunction));
+ Await(pool.forget(), p, std::move(aResolveFunction), std::move(aRejectFunction));
}
// Note: only works with exclusive MozPromise, as Promise::All would attempt
// to perform copy of nsTArrays which are disallowed.
template<typename ResolveValueType, typename RejectValueType>
typename MozPromise<ResolveValueType,
RejectValueType,
true>::AllPromiseType::ResolveOrRejectValue
--- a/dom/media/systemservices/ShmemPool.cpp
+++ b/dom/media/systemservices/ShmemPool.cpp
@@ -48,24 +48,24 @@ mozilla::ShmemBuffer ShmemPool::GetIfAva
mPoolFree--;
#ifdef DEBUG
size_t poolUse = mShmemPool.Length() - mPoolFree;
if (poolUse > mMaxPoolUse) {
mMaxPoolUse = poolUse;
LOG(("Maximum ShmemPool use increased: %zu buffers", mMaxPoolUse));
}
#endif
- return Move(res);
+ return std::move(res);
}
void ShmemPool::Put(ShmemBuffer&& aShmem)
{
MutexAutoLock lock(mMutex);
MOZ_ASSERT(mPoolFree < mShmemPool.Length());
- mShmemPool[mPoolFree] = Move(aShmem);
+ mShmemPool[mPoolFree] = std::move(aShmem);
mPoolFree++;
#ifdef DEBUG
size_t poolUse = mShmemPool.Length() - mPoolFree;
if (poolUse > 0) {
LOG_VERBOSE(("ShmemPool usage reduced to %zu buffers", poolUse));
}
#endif
}
--- a/dom/media/systemservices/ShmemPool.h
+++ b/dom/media/systemservices/ShmemPool.h
@@ -25,23 +25,23 @@ public:
ShmemBuffer() : mInitialized(false) {}
explicit ShmemBuffer(mozilla::ipc::Shmem aShmem) {
mInitialized = true;
mShmem = aShmem;
}
ShmemBuffer(ShmemBuffer&& rhs) {
mInitialized = rhs.mInitialized;
- mShmem = Move(rhs.mShmem);
+ mShmem = std::move(rhs.mShmem);
}
ShmemBuffer& operator=(ShmemBuffer&& rhs) {
MOZ_ASSERT(&rhs != this, "self-moves are prohibited");
mInitialized = rhs.mInitialized;
- mShmem = Move(rhs.mShmem);
+ mShmem = std::move(rhs.mShmem);
return *this;
}
// No copies allowed
ShmemBuffer(const ShmemBuffer&) = delete;
ShmemBuffer& operator=(const ShmemBuffer&) = delete;
bool Valid() {
@@ -130,17 +130,17 @@ public:
mPoolFree--;
#ifdef DEBUG
size_t poolUse = mShmemPool.Length() - mPoolFree;
if (poolUse > mMaxPoolUse) {
mMaxPoolUse = poolUse;
LOG(("Maximum ShmemPool use increased: %zu buffers", mMaxPoolUse));
}
#endif
- return Move(res);
+ return std::move(res);
}
private:
Mutex mMutex;
size_t mPoolFree;
#ifdef DEBUG
size_t mMaxPoolUse;
#endif
--- a/dom/media/systemservices/VideoEngine.cpp
+++ b/dom/media/systemservices/VideoEngine.cpp
@@ -189,17 +189,17 @@ VideoEngine::GetConfiguration() {
}
already_AddRefed<VideoEngine>
VideoEngine::Create(UniquePtr<const webrtc::Config>&& aConfig)
{
LOG((__PRETTY_FUNCTION__));
LOG(("Creating new VideoEngine with CaptureDeviceType %s",
aConfig->Get<webrtc::CaptureDeviceInfo>().TypeName()));
- return do_AddRef(new VideoEngine(Move(aConfig)));
+ return do_AddRef(new VideoEngine(std::move(aConfig)));
}
VideoEngine::CaptureEntry::CaptureEntry(int32_t aCapnum,
rtc::scoped_refptr<webrtc::VideoCaptureModule> aCapture)
: mCapnum(aCapnum)
, mVideoCaptureModule(aCapture)
{}
--- a/dom/media/webaudio/AudioBuffer.cpp
+++ b/dom/media/webaudio/AudioBuffer.cpp
@@ -254,17 +254,17 @@ AudioBuffer::Create(nsPIDOMWindowInner*
AudioChunk initialContents = aInitialContents;
ErrorResult rv;
RefPtr<AudioBuffer> buffer =
new AudioBuffer(aWindow, initialContents.ChannelCount(),
initialContents.mDuration, aSampleRate, rv);
if (rv.Failed()) {
return nullptr;
}
- buffer->mSharedChannels = Move(aInitialContents);
+ buffer->mSharedChannels = std::move(aInitialContents);
return buffer.forget();
}
JSObject*
AudioBuffer::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return AudioBufferBinding::Wrap(aCx, this, aGivenProto);
--- a/dom/media/webaudio/AudioBufferSourceNode.cpp
+++ b/dom/media/webaudio/AudioBufferSourceNode.cpp
@@ -751,17 +751,17 @@ AudioBufferSourceNode::SendBufferParamet
{
AudioNodeStream* ns = mStream;
if (!ns) {
return;
}
if (mBuffer) {
AudioChunk data = mBuffer->GetThreadSharedChannelsForRate(aCx);
- ns->SetBuffer(Move(data));
+ ns->SetBuffer(std::move(data));
if (mStartCalled) {
SendOffsetAndDurationParametersToStream(ns);
}
} else {
ns->SetInt32Parameter(BUFFEREND, 0);
ns->SetBuffer(AudioChunk());
--- a/dom/media/webaudio/AudioContext.cpp
+++ b/dom/media/webaudio/AudioContext.cpp
@@ -575,17 +575,17 @@ AudioContext::DecodeAudioData(const Arra
if (aSuccessCallback.WasPassed()) {
successCallback = &aSuccessCallback.Value();
}
UniquePtr<WebAudioDecodeJob> job(
new WebAudioDecodeJob(this,
promise, successCallback, failureCallback));
AsyncDecodeWebAudio(contentType.get(), data, length, *job);
// Transfer the ownership to mDecodeJobs
- mDecodeJobs.AppendElement(Move(job));
+ mDecodeJobs.AppendElement(std::move(job));
return promise.forget();
}
void
AudioContext::RemoveFromDecodeQueue(WebAudioDecodeJob* aDecodeJob)
{
// Since UniquePtr doesn't provide an operator== which allows you to compare
--- a/dom/media/webaudio/AudioNodeStream.cpp
+++ b/dom/media/webaudio/AudioNodeStream.cpp
@@ -260,22 +260,22 @@ AudioNodeStream::SetBuffer(AudioChunk&&
{
public:
Message(AudioNodeStream* aStream, AudioChunk&& aBuffer)
: ControlMessage(aStream), mBuffer(aBuffer)
{}
void Run() override
{
static_cast<AudioNodeStream*>(mStream)->Engine()->
- SetBuffer(Move(mBuffer));
+ SetBuffer(std::move(mBuffer));
}
AudioChunk mBuffer;
};
- GraphImpl()->AppendMessage(MakeUnique<Message>(this, Move(aBuffer)));
+ GraphImpl()->AppendMessage(MakeUnique<Message>(this, std::move(aBuffer)));
}
void
AudioNodeStream::SetRawArrayData(nsTArray<float>& aData)
{
class Message final : public ControlMessage
{
public:
@@ -741,17 +741,17 @@ public:
void
AudioNodeStream::ScheduleCheckForInactive()
{
if (mActiveInputCount > 0 && !mMarkAsFinishedAfterThisBlock) {
return;
}
auto message = MakeUnique<CheckForInactiveMessage>(this);
- GraphImpl()->RunMessageAfterProcessing(Move(message));
+ GraphImpl()->RunMessageAfterProcessing(std::move(message));
}
void
AudioNodeStream::CheckForInactive()
{
if (((mActiveInputCount > 0 || mEngine->IsActive()) &&
!mMarkAsFinishedAfterThisBlock) ||
!mIsActive) {
--- a/dom/media/webaudio/ConvolverNode.cpp
+++ b/dom/media/webaudio/ConvolverNode.cpp
@@ -274,22 +274,22 @@ ConvolverNode::SetBuffer(JSContext* aCx,
}
auto floatData = static_cast<float*>(floatBuffer->Data());
for (size_t i = 0; i < data.ChannelCount(); ++i) {
ConvertAudioSamples(data.ChannelData<int16_t>()[i],
floatData, data.mDuration);
data.mChannelData[i] = floatData;
floatData += data.mDuration;
}
- data.mBuffer = Move(floatBuffer);
+ data.mBuffer = std::move(floatBuffer);
data.mBufferFormat = AUDIO_FORMAT_FLOAT32;
}
SendDoubleParameterToStream(ConvolverNodeEngine::SAMPLE_RATE,
aBuffer->SampleRate());
- ns->SetBuffer(Move(data));
+ ns->SetBuffer(std::move(data));
} else {
ns->SetBuffer(AudioChunk());
}
mBuffer = aBuffer;
}
void
--- a/dom/media/webaudio/MediaBufferDecoder.cpp
+++ b/dom/media/webaudio/MediaBufferDecoder.cpp
@@ -468,17 +468,17 @@ MediaDecodeTask::CallbackTheResult()
bool
WebAudioDecodeJob::AllocateBuffer()
{
MOZ_ASSERT(!mOutput);
MOZ_ASSERT(NS_IsMainThread());
// Now create the AudioBuffer
mOutput = AudioBuffer::Create(mContext->GetOwner(),
- mContext->SampleRate(), Move(mBuffer));
+ mContext->SampleRate(), std::move(mBuffer));
return mOutput != nullptr;
}
void
AsyncDecodeWebAudio(const char* aContentType, uint8_t* aBuffer,
uint32_t aLength, WebAudioDecodeJob& aDecodeJob)
{
Maybe<MediaContainerType> containerType = MakeMediaContainerType(aContentType);
--- a/dom/media/webaudio/OscillatorNode.cpp
+++ b/dom/media/webaudio/OscillatorNode.cpp
@@ -498,17 +498,17 @@ void OscillatorNode::SendPeriodicWaveToS
{
NS_ASSERTION(mType == OscillatorType::Custom,
"Sending custom waveform to engine thread with non-custom type");
MOZ_ASSERT(mStream, "Missing node stream.");
MOZ_ASSERT(mPeriodicWave, "Send called without PeriodicWave object.");
SendInt32ParameterToStream(OscillatorNodeEngine::DISABLE_NORMALIZATION,
mPeriodicWave->DisableNormalization());
AudioChunk data = mPeriodicWave->GetThreadSharedBuffer();
- mStream->SetBuffer(Move(data));
+ mStream->SetBuffer(std::move(data));
}
void
OscillatorNode::Start(double aWhen, ErrorResult& aRv)
{
if (!WebAudioUtils::IsTimeValid(aWhen)) {
aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
return;
--- a/dom/media/webaudio/PannerNode.cpp
+++ b/dom/media/webaudio/PannerNode.cpp
@@ -105,17 +105,17 @@ public:
{
MOZ_ASSERT(NS_IsMainThread());
if (mHRTFPanner) {
return;
}
// HRTFDatabaseLoader needs to be fetched on the main thread.
already_AddRefed<HRTFDatabaseLoader> loader =
HRTFDatabaseLoader::createAndLoadAsynchronouslyIfNecessary(NodeMainThread()->Context()->SampleRate());
- mHRTFPanner = new HRTFPanner(NodeMainThread()->Context()->SampleRate(), Move(loader));
+ mHRTFPanner = new HRTFPanner(NodeMainThread()->Context()->SampleRate(), std::move(loader));
}
void SetInt32Parameter(uint32_t aIndex, int32_t aParam) override
{
switch (aIndex) {
case PannerNode::PANNING_MODEL:
switch (PanningModelType(aParam)) {
case PanningModelType::Equalpower:
--- a/dom/media/webaudio/PeriodicWave.cpp
+++ b/dom/media/webaudio/PeriodicWave.cpp
@@ -37,17 +37,17 @@ PeriodicWave::PeriodicWave(AudioContext*
RefPtr<SharedBuffer> buffer =
SharedBuffer::Create(sizeof(float) * aLength * 2, fallible);
if (!buffer) {
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
return;
}
auto data = static_cast<float*>(buffer->Data());
- mCoefficients.mBuffer = Move(buffer);
+ mCoefficients.mBuffer = std::move(buffer);
if (aRealData) {
PodCopy(data, aRealData, aLength);
} else {
PodZero(data, aLength);
}
mCoefficients.mChannelData.AppendElement(data);
--- a/dom/media/webm/NesteggPacketHolder.h
+++ b/dom/media/webm/NesteggPacketHolder.h
@@ -93,17 +93,17 @@ class WebMPacketQueue {
return mQueue.size();
}
void Push(NesteggPacketHolder* aItem) {
mQueue.push_back(aItem);
}
void PushFront(NesteggPacketHolder* aItem) {
- mQueue.push_front(Move(aItem));
+ mQueue.push_front(std::move(aItem));
}
already_AddRefed<NesteggPacketHolder> PopFront() {
RefPtr<NesteggPacketHolder> result = mQueue.front().forget();
mQueue.pop_front();
return result.forget();
}
--- a/dom/media/webm/WebMDemuxer.cpp
+++ b/dom/media/webm/WebMDemuxer.cpp
@@ -557,17 +557,17 @@ WebMDemuxer::GetTrackCrypto(TrackInfo::T
for (i = 0; i < contentEncKeyIdLength; i++) {
initData.AppendElement(contentEncKeyId[i]);
}
if (!initData.IsEmpty()) {
crypto.mValid = true;
// crypto.mMode is not used for WebMs
crypto.mIVSize = WEBM_IV_SIZE;
- crypto.mKeyId = Move(initData);
+ crypto.mKeyId = std::move(initData);
}
return crypto;
}
nsresult
WebMDemuxer::GetNextPacket(TrackInfo::TrackType aType,
MediaRawDataQueue *aSamples)
@@ -1232,17 +1232,17 @@ WebMTrackDemuxer::SetNextKeyFrameTime()
} else if (!foundKeyframe &&
sampleTimecode > startTime.ref() + MAX_LOOK_AHEAD) {
WEBM_DEBUG("Couldn't find keyframe in a reasonable time, aborting");
break;
}
}
// We may have demuxed more than intended, so ensure that all frames are kept
// in the right order.
- mSamples.PushFront(Move(skipSamplesQueue));
+ mSamples.PushFront(std::move(skipSamplesQueue));
if (frameTime.IsValid()) {
mNextKeyframeTime.emplace(frameTime);
WEBM_DEBUG("Next Keyframe %f (%u queued %.02fs)",
mNextKeyframeTime.value().ToSeconds(),
uint32_t(mSamples.GetSize()),
(mSamples.Last()->mTimecode - mSamples.First()->mTimecode).ToSeconds());
} else {
@@ -1316,17 +1316,17 @@ WebMTrackDemuxer::SkipToNextRandomAccess
}
if (NS_SUCCEEDED(rv)) {
SetNextKeyFrameTime();
}
if (found) {
return SkipAccessPointPromise::CreateAndResolve(parsed, __func__);
} else {
SkipFailureHolder failure(NS_ERROR_DOM_MEDIA_END_OF_STREAM, parsed);
- return SkipAccessPointPromise::CreateAndReject(Move(failure), __func__);
+ return SkipAccessPointPromise::CreateAndReject(std::move(failure), __func__);
}
}
media::TimeIntervals
WebMTrackDemuxer::GetBuffered()
{
return mParent->GetBuffered();
}
--- a/dom/media/webm/WebMDemuxer.h
+++ b/dom/media/webm/WebMDemuxer.h
@@ -34,26 +34,26 @@ class MediaRawDataQueue
void Push(MediaRawData* aItem)
{
mQueue.push_back(aItem);
}
void Push(already_AddRefed<MediaRawData>&& aItem)
{
- mQueue.push_back(Move(aItem));
+ mQueue.push_back(std::move(aItem));
}
void PushFront(MediaRawData* aItem) {
mQueue.push_front(aItem);
}
void PushFront(already_AddRefed<MediaRawData>&& aItem)
{
- mQueue.push_front(Move(aItem));
+ mQueue.push_front(std::move(aItem));
}
void PushFront(MediaRawDataQueue&& aOther)
{
while (!aOther.mQueue.empty()) {
PushFront(aOther.Pop());
}
}
--- a/dom/media/webrtc/MediaEngineDefault.cpp
+++ b/dom/media/webrtc/MediaEngineDefault.cpp
@@ -315,17 +315,17 @@ MediaEngineDefaultVideoSource::GenerateF
// SetData copies data, so we can free the frame
ReleaseFrame(data);
if (!setData) {
return;
}
MutexAutoLock lock(mMutex);
- mImage = Move(ycbcr_image);
+ mImage = std::move(ycbcr_image);
}
void
MediaEngineDefaultVideoSource::Pull(const RefPtr<const AllocationHandle>& aHandle,
const RefPtr<SourceMediaStream>& aStream,
TrackID aTrackID,
StreamTime aDesiredTime,
const PrincipalHandle& aPrincipalHandle)
--- a/dom/media/webrtc/MediaEngineRemoteVideoSource.cpp
+++ b/dom/media/webrtc/MediaEngineRemoteVideoSource.cpp
@@ -99,17 +99,17 @@ MediaEngineRemoteVideoSource::Shutdown()
}
void
MediaEngineRemoteVideoSource::SetName(nsString aName)
{
LOG((__PRETTY_FUNCTION__));
AssertIsOnOwningThread();
- mDeviceName = Move(aName);
+ mDeviceName = std::move(aName);
bool hasFacingMode = false;
VideoFacingModeEnum facingMode = VideoFacingModeEnum::User;
// Set facing mode based on device name.
#if defined(ANDROID)
// Names are generated. Example: "Camera 0, Facing back, Orientation 90"
//
// See media/webrtc/trunk/webrtc/modules/video_capture/android/java/src/org/
@@ -953,17 +953,17 @@ MediaEngineRemoteVideoSource::ChooseCapa
// We'll adjust the width too so the aspect ratio is retained.
cap.width = cap.height * prefWidth / prefHeight;
}
if (candidateSet.Contains(cap, CapabilityComparator())) {
continue;
}
LogCapability("Hardcoded capability", cap, 0);
- candidateSet.AppendElement(CapabilityCandidate(Move(cap)));
+ candidateSet.AppendElement(CapabilityCandidate(std::move(cap)));
}
}
// First, filter capabilities by required constraints (min, max, exact).
for (size_t i = 0; i < candidateSet.Length();) {
auto& candidate = candidateSet[i];
candidate.mDistance =
@@ -990,17 +990,17 @@ MediaEngineRemoteVideoSource::ChooseCapa
cs, aDeviceId, aCalculate) == UINT32_MAX) {
rejects.AppendElement(candidateSet[i]);
candidateSet.RemoveElementAt(i);
} else {
++i;
}
}
if (!candidateSet.Length()) {
- candidateSet.AppendElements(Move(rejects));
+ candidateSet.AppendElements(std::move(rejects));
}
}
MOZ_ASSERT(candidateSet.Length(),
"advanced constraints filtering step can't reduce candidates to zero");
// Remaining algorithm is up to the UA.
TrimLessFitCandidates(candidateSet);
--- a/dom/media/webrtc/MediaEngineWebRTCAudio.cpp
+++ b/dom/media/webrtc/MediaEngineWebRTCAudio.cpp
@@ -529,17 +529,17 @@ MediaEngineWebRTCMicrophoneSource::Updat
void
MediaEngineWebRTCMicrophoneSource::ApplySettings(const MediaEnginePrefs& aPrefs,
RefPtr<MediaStreamGraphImpl> aGraph)
{
AssertIsOnOwningThread();
MOZ_DIAGNOSTIC_ASSERT(aGraph);
RefPtr<MediaEngineWebRTCMicrophoneSource> that = this;
- NS_DispatchToMainThread(media::NewRunnableFrom([that, graph = Move(aGraph), aPrefs]() mutable {
+ NS_DispatchToMainThread(media::NewRunnableFrom([that, graph = std::move(aGraph), aPrefs]() mutable {
that->mSettings->mEchoCancellation.Value() = aPrefs.mAecOn;
that->mSettings->mAutoGainControl.Value() = aPrefs.mAgcOn;
that->mSettings->mNoiseSuppression.Value() = aPrefs.mNoiseOn;
that->mSettings->mChannelCount.Value() = aPrefs.mChannels;
class Message : public ControlMessage {
public:
Message(MediaEngineWebRTCMicrophoneSource* aSource,
--- a/dom/media/webrtc/MediaTrackConstraints.cpp
+++ b/dom/media/webrtc/MediaTrackConstraints.cpp
@@ -492,17 +492,17 @@ MediaConstraintsHelper::SelectSettings(
aggregateConstraints.AppendElement(&c);
std::multimap<uint32_t, RefPtr<MediaDevice>> ordered;
for (uint32_t i = 0; i < aDevices.Length();) {
uint32_t distance =
aDevices[i]->GetBestFitnessDistance(aggregateConstraints, aIsChrome);
if (distance == UINT32_MAX) {
- unsatisfactory.AppendElement(Move(aDevices[i]));
+ unsatisfactory.AppendElement(std::move(aDevices[i]));
aDevices.RemoveElementAt(i);
} else {
ordered.insert(std::make_pair(distance, aDevices[i]));
++i;
}
}
if (aDevices.IsEmpty()) {
return FindBadConstraint(c, unsatisfactory);
@@ -518,24 +518,24 @@ MediaConstraintsHelper::SelectSettings(
for (int i = 0; i < int(c.mAdvanced.size()); i++) {
aggregateConstraints.AppendElement(&c.mAdvanced[i]);
nsTArray<RefPtr<MediaDevice>> rejects;
for (uint32_t j = 0; j < aDevices.Length();) {
uint32_t distance = aDevices[j]->GetBestFitnessDistance(aggregateConstraints,
aIsChrome);
if (distance == UINT32_MAX) {
- rejects.AppendElement(Move(aDevices[j]));
+ rejects.AppendElement(std::move(aDevices[j]));
aDevices.RemoveElementAt(j);
} else {
++j;
}
}
if (aDevices.IsEmpty()) {
- aDevices.AppendElements(Move(rejects));
+ aDevices.AppendElements(std::move(rejects));
aggregateConstraints.RemoveLastElement();
}
}
return nullptr;
}
/* static */ const char*
MediaConstraintsHelper::FindBadConstraint(
--- a/dom/media/webrtc/RTCCertificate.cpp
+++ b/dom/media/webrtc/RTCCertificate.cpp
@@ -309,17 +309,17 @@ RTCCertificate::RTCCertificate(nsIGlobal
RefPtr<DtlsIdentity>
RTCCertificate::CreateDtlsIdentity() const
{
if (!mPrivateKey || !mCertificate) {
return nullptr;
}
UniqueSECKEYPrivateKey key(SECKEY_CopyPrivateKey(mPrivateKey.get()));
UniqueCERTCertificate cert(CERT_DupCertificate(mCertificate.get()));
- RefPtr<DtlsIdentity> id = new DtlsIdentity(Move(key), Move(cert), mAuthType);
+ RefPtr<DtlsIdentity> id = new DtlsIdentity(std::move(key), std::move(cert), mAuthType);
return id;
}
JSObject*
RTCCertificate::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
return RTCCertificateBinding::Wrap(aCx, this, aGivenProto);
}
--- a/dom/messagechannel/MessagePort.cpp
+++ b/dom/messagechannel/MessagePort.cpp
@@ -298,17 +298,17 @@ MessagePort::Initialize(const nsID& aUUI
[self]() { self->CloseForced(); });
if (NS_WARN_IF(!strongWorkerRef)) {
// The worker is shutting down.
aRv.Throw(NS_ERROR_FAILURE);
return;
}
MOZ_ASSERT(!mWorkerRef);
- mWorkerRef = Move(strongWorkerRef);
+ mWorkerRef = std::move(strongWorkerRef);
} else if (GetOwner()) {
MOZ_ASSERT(NS_IsMainThread());
mInnerID = GetOwner()->WindowID();
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->AddObserver(this, "inner-window-destroyed", false);
}
@@ -519,17 +519,17 @@ MessagePort::CloseInternal(bool aSoftly)
if (!aSoftly) {
mMessages.Clear();
}
if (mState == eStateUnshippedEntangled) {
MOZ_ASSERT(mUnshippedEntangledPort);
// This avoids loops.
- RefPtr<MessagePort> port = Move(mUnshippedEntangledPort);
+ RefPtr<MessagePort> port = std::move(mUnshippedEntangledPort);
MOZ_ASSERT(mUnshippedEntangledPort == nullptr);
mState = eStateDisentangledForClose;
port->CloseInternal(aSoftly);
UpdateMustKeepAlive();
return;
}
--- a/dom/messagechannel/MessagePortService.cpp
+++ b/dom/messagechannel/MessagePortService.cpp
@@ -141,17 +141,17 @@ MessagePortService::RequestEntangling(Me
data->mWaitingForNewParent = false;
// We want to ensure we clear data->mMessages even if we early return, while
// also ensuring that its contents remain alive until after array's contents
// are destroyed because of JSStructuredCloneData borrowing. So we use
// Move to initialize things swapped and do it before we declare `array` so
// that reverse destruction order works for us.
FallibleTArray<RefPtr<SharedMessagePortMessage>>
- messages(Move(data->mMessages));
+ messages(std::move(data->mMessages));
FallibleTArray<ClonedMessageData> array;
if (!SharedMessagePortMessage::FromSharedToMessagesParent(aParent,
messages,
array)) {
CloseAll(aParent->ID());
return false;
}
--- a/dom/notification/Notification.cpp
+++ b/dom/notification/Notification.cpp
@@ -110,17 +110,17 @@ public:
nsString(aBody),
nsString(aTag),
nsString(aIcon),
nsString(aData),
nsString(aBehavior),
nsString(aServiceWorkerRegistrationScope),
};
- mStrings.AppendElement(Move(strings));
+ mStrings.AppendElement(std::move(strings));
return NS_OK;
}
NS_IMETHOD Done() override = 0;
protected:
virtual ~ScopeCheckingGetCallback()
{}
@@ -512,17 +512,17 @@ public:
enum NotificationAction {
eShow,
eClose
};
NotificationTask(const char* aName, UniquePtr<NotificationRef> aRef,
NotificationAction aAction)
: Runnable(aName)
- , mNotificationRef(Move(aRef)), mAction(aAction)
+ , mNotificationRef(std::move(aRef)), mAction(aAction)
{}
NS_IMETHOD
Run() override;
protected:
virtual ~NotificationTask() {}
UniquePtr<NotificationRef> mNotificationRef;
@@ -851,17 +851,17 @@ NS_IMPL_ISUPPORTS(NotificationObserver,
class MainThreadNotificationObserver : public nsIObserver
{
public:
UniquePtr<NotificationRef> mNotificationRef;
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
explicit MainThreadNotificationObserver(UniquePtr<NotificationRef> aRef)
- : mNotificationRef(Move(aRef))
+ : mNotificationRef(std::move(aRef))
{
AssertIsOnMainThread();
}
protected:
virtual ~MainThreadNotificationObserver()
{
AssertIsOnMainThread();
@@ -1202,17 +1202,17 @@ Notification::GetPrincipal()
class WorkerNotificationObserver final : public MainThreadNotificationObserver
{
public:
NS_INLINE_DECL_REFCOUNTING_INHERITED(WorkerNotificationObserver,
MainThreadNotificationObserver)
NS_DECL_NSIOBSERVER
explicit WorkerNotificationObserver(UniquePtr<NotificationRef> aRef)
- : MainThreadNotificationObserver(Move(aRef))
+ : MainThreadNotificationObserver(std::move(aRef))
{
AssertIsOnMainThread();
MOZ_ASSERT(mNotificationRef->GetNotification()->mWorkerPrivate);
}
void
ForgetNotification()
{
@@ -1673,20 +1673,20 @@ Notification::ShowInternal()
nsCOMPtr<nsIObserver> observer;
if (mScope.IsEmpty()) {
// Ownership passed to observer.
if (mWorkerPrivate) {
// Scope better be set on ServiceWorker initiated requests.
MOZ_ASSERT(!mWorkerPrivate->IsServiceWorker());
// Keep a pointer so that the feature can tell the observer not to release
// the notification.
- mObserver = new WorkerNotificationObserver(Move(ownership));
+ mObserver = new WorkerNotificationObserver(std::move(ownership));
observer = mObserver;
} else {
- observer = new MainThreadNotificationObserver(Move(ownership));
+ observer = new MainThreadNotificationObserver(std::move(ownership));
}
} else {
isPersistent = true;
// This observer does not care about the Notification. It will be released
// at the end of this function.
//
// The observer is wholly owned by the NotificationObserver passed to the alert service.
nsAutoString behavior;
@@ -2025,17 +2025,17 @@ class WorkerGetResultRunnable final : pu
RefPtr<PromiseWorkerProxy> mPromiseProxy;
const nsTArray<NotificationStrings> mStrings;
public:
WorkerGetResultRunnable(WorkerPrivate* aWorkerPrivate,
PromiseWorkerProxy* aPromiseProxy,
const nsTArray<NotificationStrings>&& aStrings)
: NotificationWorkerRunnable(aWorkerPrivate)
, mPromiseProxy(aPromiseProxy)
- , mStrings(Move(aStrings))
+ , mStrings(std::move(aStrings))
{
}
void
WorkerRunInternal(WorkerPrivate* aWorkerPrivate) override
{
RefPtr<Promise> workerPromise = mPromiseProxy->WorkerPromise();
@@ -2091,17 +2091,17 @@ public:
MutexAutoLock lock(proxy->Lock());
if (proxy->CleanedUp()) {
return NS_OK;
}
RefPtr<WorkerGetResultRunnable> r =
new WorkerGetResultRunnable(proxy->GetWorkerPrivate(),
proxy,
- Move(mStrings));
+ std::move(mStrings));
r->Dispatch();
return NS_OK;
}
private:
~WorkerGetCallback()
{}
@@ -2206,17 +2206,17 @@ Notification::Close()
{
AssertIsOnTargetThread();
auto ref = MakeUnique<NotificationRef>(this);
if (!ref->Initialized()) {
return;
}
nsCOMPtr<nsIRunnable> closeNotificationTask =
- new NotificationTask("Notification::Close", Move(ref),
+ new NotificationTask("Notification::Close", std::move(ref),
NotificationTask::eClose);
nsresult rv = DispatchToMainThread(closeNotificationTask.forget());
if (NS_FAILED(rv)) {
DispatchTrustedEvent(NS_LITERAL_STRING("error"));
// If dispatch fails, NotificationTask will release the ref when it goes
// out of scope at the end of this function.
}
@@ -2654,17 +2654,17 @@ Notification::CreateAndShow(JSContext* a
auto ref = MakeUnique<NotificationRef>(notification);
if (NS_WARN_IF(!ref->Initialized())) {
aRv.Throw(NS_ERROR_DOM_ABORT_ERR);
return nullptr;
}
// Queue a task to show the notification.
nsCOMPtr<nsIRunnable> showNotificationTask =
- new NotificationTask("Notification::CreateAndShow", Move(ref),
+ new NotificationTask("Notification::CreateAndShow", std::move(ref),
NotificationTask::eShow);
nsresult rv =
notification->DispatchToMainThread(showNotificationTask.forget());
if (NS_WARN_IF(NS_FAILED(rv))) {
notification->DispatchTrustedEvent(NS_LITERAL_STRING("error"));
}
@@ -2722,23 +2722,23 @@ Notification::Observe(nsISupports* aSubj
return NS_OK;
}
nsresult
Notification::DispatchToMainThread(already_AddRefed<nsIRunnable>&& aRunnable)
{
if (mWorkerPrivate) {
- return mWorkerPrivate->DispatchToMainThread(Move(aRunnable));
+ return mWorkerPrivate->DispatchToMainThread(std::move(aRunnable));
}
AssertIsOnMainThread();
if (nsCOMPtr<nsIGlobalObject> global = GetOwnerGlobal()) {
if (nsIEventTarget* target = global->EventTargetFor(TaskCategory::Other)) {
- return target->Dispatch(Move(aRunnable), nsIEventTarget::DISPATCH_NORMAL);
+ return target->Dispatch(std::move(aRunnable), nsIEventTarget::DISPATCH_NORMAL);
}
}
nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
MOZ_ASSERT(mainTarget);
- return mainTarget->Dispatch(Move(aRunnable), nsIEventTarget::DISPATCH_NORMAL);
+ return mainTarget->Dispatch(std::move(aRunnable), nsIEventTarget::DISPATCH_NORMAL);
}
} // namespace dom
} // namespace mozilla
--- a/dom/performance/PerformanceMainThread.cpp
+++ b/dom/performance/PerformanceMainThread.cpp
@@ -154,17 +154,17 @@ PerformanceMainThread::AddEntry(nsIHttpC
entryName));
if (!performanceTimingData) {
return;
}
// The PerformanceResourceTiming object will use the PerformanceTimingData
// object to get all the required timings.
RefPtr<PerformanceResourceTiming> performanceEntry =
- new PerformanceResourceTiming(Move(performanceTimingData), this,
+ new PerformanceResourceTiming(std::move(performanceTimingData), this,
entryName);
performanceEntry->SetInitiatorType(initiatorType);
InsertResourceEntry(performanceEntry);
}
// To be removed once bug 1124165 lands
bool
@@ -320,17 +320,17 @@ PerformanceMainThread::EnsureDocEntry()
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(mChannel);
if (httpChannel) {
timing->SetPropertiesFromHttpChannel(httpChannel);
}
nsAutoString name;
GetURLSpecFromChannel(mChannel, name);
- mDocEntry = new PerformanceNavigationTiming(Move(timing), this, name);
+ mDocEntry = new PerformanceNavigationTiming(std::move(timing), this, name);
}
}
void
PerformanceMainThread::CreateDocumentEntry(nsITimedChannel* aChannel)
{
MOZ_ASSERT(aChannel);
MOZ_ASSERT(!mDocEntry, "mDocEntry should be null.");
@@ -339,17 +339,17 @@ PerformanceMainThread::CreateDocumentEnt
return;
}
nsAutoString name;
GetURLSpecFromChannel(aChannel, name);
UniquePtr<PerformanceTimingData> timing(
new PerformanceTimingData(aChannel, nullptr, 0));
- mDocEntry = new PerformanceNavigationTiming(Move(timing), this, name);
+ mDocEntry = new PerformanceNavigationTiming(std::move(timing), this, name);
}
void
PerformanceMainThread::GetEntries(nsTArray<RefPtr<PerformanceEntry>>& aRetval)
{
// We return an empty list when 'privacy.resistFingerprinting' is on.
if (nsContentUtils::ShouldResistFingerprinting()) {
aRetval.Clear();
--- a/dom/performance/PerformanceNavigationTiming.h
+++ b/dom/performance/PerformanceNavigationTiming.h
@@ -27,17 +27,17 @@ public:
// Note that aPerformanceTiming must be initalized with zeroTime = 0
// so that timestamps are relative to startTime, as opposed to the
// performance.timing object for which timestamps are absolute and has a
// zeroTime initialized to navigationStart
PerformanceNavigationTiming(UniquePtr<PerformanceTimingData>&& aPerformanceTiming,
Performance* aPerformance,
const nsAString& aName)
- : PerformanceResourceTiming(Move(aPerformanceTiming), aPerformance, aName)
+ : PerformanceResourceTiming(std::move(aPerformanceTiming), aPerformance, aName)
{
SetEntryType(NS_LITERAL_STRING("navigation"));
SetInitiatorType(NS_LITERAL_STRING("navigation"));
}
DOMHighResTimeStamp Duration() const override
{
DOMHighResTimeStamp rawDuration = LoadEventEnd() - StartTime();
--- a/dom/performance/PerformanceResourceTiming.cpp
+++ b/dom/performance/PerformanceResourceTiming.cpp
@@ -24,17 +24,17 @@ NS_INTERFACE_MAP_END_INHERITING(Performa
NS_IMPL_ADDREF_INHERITED(PerformanceResourceTiming, PerformanceEntry)
NS_IMPL_RELEASE_INHERITED(PerformanceResourceTiming, PerformanceEntry)
PerformanceResourceTiming::PerformanceResourceTiming(UniquePtr<PerformanceTimingData>&& aPerformanceTiming,
Performance* aPerformance,
const nsAString& aName)
: PerformanceEntry(aPerformance->GetParentObject(), aName, NS_LITERAL_STRING("resource"))
- , mTimingData(Move(aPerformanceTiming))
+ , mTimingData(std::move(aPerformanceTiming))
, mPerformance(aPerformance)
{
MOZ_ASSERT(aPerformance, "Parent performance object should be provided");
if (NS_IsMainThread()) {
// Used to check if an addon content script has access to this timing.
// We don't need it in workers, and ignore mOriginalURI if null.
NS_NewURI(getter_AddRefs(mOriginalURI), aName);
}
--- a/dom/performance/PerformanceStorageWorker.cpp
+++ b/dom/performance/PerformanceStorageWorker.cpp
@@ -13,17 +13,17 @@ namespace mozilla {
namespace dom {
class PerformanceProxyData
{
public:
PerformanceProxyData(UniquePtr<PerformanceTimingData>&& aData,
const nsAString& aInitiatorType,
const nsAString& aEntryName)
- : mData(Move(aData))
+ : mData(std::move(aData))
, mInitiatorType(aInitiatorType)
, mEntryName(aEntryName)
{}
UniquePtr<PerformanceTimingData> mData;
nsString mInitiatorType;
nsString mEntryName;
};
@@ -35,23 +35,23 @@ namespace {
class PerformanceEntryAdder final : public WorkerControlRunnable
{
public:
PerformanceEntryAdder(WorkerPrivate* aWorkerPrivate,
PerformanceStorageWorker* aStorage,
UniquePtr<PerformanceProxyData>&& aData)
: WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount)
, mStorage(aStorage)
- , mData(Move(aData))
+ , mData(std::move(aData))
{}
bool
WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
{
- mStorage->AddEntryOnWorker(Move(mData));
+ mStorage->AddEntryOnWorker(std::move(mData));
return true;
}
nsresult
Cancel() override
{
mStorage->ShutdownOnWorker();
return WorkerRunnable::Cancel();
@@ -146,21 +146,21 @@ PerformanceStorageWorker::AddEntry(nsIHt
UniquePtr<PerformanceTimingData> performanceTimingData(
PerformanceTimingData::Create(aTimedChannel, aChannel, 0, initiatorType,
entryName));
if (!performanceTimingData) {
return;
}
UniquePtr<PerformanceProxyData> data(
- new PerformanceProxyData(Move(performanceTimingData), initiatorType,
+ new PerformanceProxyData(std::move(performanceTimingData), initiatorType,
entryName));
RefPtr<PerformanceEntryAdder> r =
- new PerformanceEntryAdder(workerPrivate, this, Move(data));
+ new PerformanceEntryAdder(workerPrivate, this, std::move(data));
Unused << NS_WARN_IF(!r->Dispatch());
}
void
PerformanceStorageWorker::ShutdownOnWorker()
{
MutexAutoLock lock(mMutex);
@@ -172,17 +172,17 @@ PerformanceStorageWorker::ShutdownOnWork
mWorkerRef = nullptr;
}
void
PerformanceStorageWorker::AddEntryOnWorker(UniquePtr<PerformanceProxyData>&& aData)
{
RefPtr<Performance> performance;
- UniquePtr<PerformanceProxyData> data = Move(aData);
+ UniquePtr<PerformanceProxyData> data = std::move(aData);
{
MutexAutoLock lock(mMutex);
if (!mWorkerRef) {
return;
}
@@ -195,17 +195,17 @@ PerformanceStorageWorker::AddEntryOnWork
performance = scope->GetPerformance();
}
if (NS_WARN_IF(!performance)) {
return;
}
RefPtr<PerformanceResourceTiming> performanceEntry =
- new PerformanceResourceTiming(Move(data->mData), performance,
+ new PerformanceResourceTiming(std::move(data->mData), performance,
data->mEntryName);
performanceEntry->SetInitiatorType(data->mInitiatorType);
performance->InsertResourceEntry(performanceEntry);
}
} // namespace dom
} // namespace mozilla
--- a/dom/plugins/ipc/FunctionBrokerChild.cpp
+++ b/dom/plugins/ipc/FunctionBrokerChild.cpp
@@ -16,31 +16,31 @@ bool
FunctionBrokerChild::IsDispatchThread()
{
return mThread->IsOnThread();
}
void
FunctionBrokerChild::PostToDispatchThread(already_AddRefed<nsIRunnable>&& runnable)
{
- mThread->Dispatch(Move(runnable));
+ mThread->Dispatch(std::move(runnable));
}
/* static */ bool
FunctionBrokerChild::Initialize(Endpoint<PFunctionBrokerChild>&& aBrokerEndpoint)
{
MOZ_RELEASE_ASSERT(XRE_IsPluginProcess(),
"FunctionBrokerChild can only be used in plugin processes");
MOZ_ASSERT(!sInstance);
FunctionBrokerThread* thread = FunctionBrokerThread::Create();
if (!thread) {
return false;
}
- sInstance = new FunctionBrokerChild(thread, Move(aBrokerEndpoint));
+ sInstance = new FunctionBrokerChild(thread, std::move(aBrokerEndpoint));
return true;
}
/* static */ FunctionBrokerChild*
FunctionBrokerChild::GetInstance()
{
MOZ_RELEASE_ASSERT(XRE_IsPluginProcess(),
"FunctionBrokerChild can only be used in plugin processes");
@@ -53,17 +53,17 @@ FunctionBrokerChild::FunctionBrokerChild
Endpoint<PFunctionBrokerChild>&& aEndpoint) :
mThread(aThread)
, mShutdownDone(false)
, mMonitor("FunctionBrokerChild Lock")
{
MOZ_ASSERT(aThread);
PostToDispatchThread(NewNonOwningRunnableMethod<Endpoint<PFunctionBrokerChild>&&>(
"FunctionBrokerChild::Bind", this, &FunctionBrokerChild::Bind,
- Move(aEndpoint)));
+ std::move(aEndpoint)));
}
void
FunctionBrokerChild::Bind(Endpoint<PFunctionBrokerChild>&& aEndpoint)
{
MOZ_RELEASE_ASSERT(mThread->IsOnThread());
DebugOnly<bool> ok = aEndpoint.Bind(this);
MOZ_ASSERT(ok);
--- a/dom/plugins/ipc/FunctionBrokerParent.cpp
+++ b/dom/plugins/ipc/FunctionBrokerParent.cpp
@@ -25,28 +25,28 @@ FunctionBrokerParent::Create(Endpoint<PF
if (!thread) {
return nullptr;
}
// We get the FunctionHooks so that they are created here, not on the
// message thread.
FunctionHook::GetHooks();
- return new FunctionBrokerParent(thread, Move(aParentEnd));
+ return new FunctionBrokerParent(thread, std::move(aParentEnd));
}
FunctionBrokerParent::FunctionBrokerParent(FunctionBrokerThread* aThread,
Endpoint<PFunctionBrokerParent>&& aParentEnd) :
mThread(aThread)
, mMonitor("FunctionBrokerParent Lock")
, mShutdownDone(false)
{
MOZ_ASSERT(mThread);
mThread->Dispatch(NewNonOwningRunnableMethod<Endpoint<PFunctionBrokerParent>&&>(
- "FunctionBrokerParent::Bind", this, &FunctionBrokerParent::Bind, Move(aParentEnd)));
+ "FunctionBrokerParent::Bind", this, &FunctionBrokerParent::Bind, std::move(aParentEnd)));
}
FunctionBrokerParent::~FunctionBrokerParent()
{
#if defined(XP_WIN) && defined(MOZ_SANDBOX)
// Clean up any file permissions that we granted to the child process.
MOZ_RELEASE_ASSERT(NS_IsMainThread());
RemovePermissionsForProcess(OtherPid());
--- a/dom/plugins/ipc/FunctionBrokerThread.h
+++ b/dom/plugins/ipc/FunctionBrokerThread.h
@@ -12,17 +12,17 @@
namespace mozilla {
namespace plugins {
class FunctionBrokerThread
{
public:
void Dispatch(already_AddRefed<nsIRunnable>&& aRunnable)
{
- mThread->Dispatch(Move(aRunnable), nsIEventTarget::NS_DISPATCH_NORMAL);
+ mThread->Dispatch(std::move(aRunnable), nsIEventTarget::NS_DISPATCH_NORMAL);
}
bool IsOnThread()
{
bool on;
return NS_SUCCEEDED(mThread->IsOnCurrentThread(&on)) && on;
}
--- a/dom/plugins/ipc/IpdlTuple.h
+++ b/dom/plugins/ipc/IpdlTuple.h
@@ -44,17 +44,17 @@ private:
struct InvalidType {};
// Like Variant but with a default constructor.
template <typename ... Types>
struct MaybeVariant
{
public:
MaybeVariant() : mValue(InvalidType()) {}
- MaybeVariant(MaybeVariant&& o) : mValue(Move(o.mValue)) {}
+ MaybeVariant(MaybeVariant&& o) : mValue(std::move(o.mValue)) {}
template <typename Param> void Set(const Param& aParam)
{
mValue = mozilla::AsVariant(aParam);
}
typedef mozilla::Variant<InvalidType, Types...> MaybeVariantType;
MaybeVariantType& GetVariant() { return mValue; }
--- a/dom/plugins/ipc/PluginModuleChild.cpp
+++ b/dom/plugins/ipc/PluginModuleChild.cpp
@@ -77,17 +77,17 @@ PluginModuleChild* gChromeInstance = nul
static bool gDelayFlashFocusReplyUntilEval = false;
#endif
/* static */
bool
PluginModuleChild::CreateForContentProcess(Endpoint<PPluginModuleChild>&& aEndpoint)
{
auto* child = new PluginModuleChild(false);
- return child->InitForContent(Move(aEndpoint));
+ return child->InitForContent(std::move(aEndpoint));
}
PluginModuleChild::PluginModuleChild(bool aIsChrome)
: mLibrary(0)
, mPluginFilename("")
, mQuirks(QUIRKS_NOT_INITIALIZED)
, mIsChrome(aIsChrome)
, mHasShutdown(false)
@@ -177,17 +177,17 @@ PluginModuleChild::InitForContent(Endpoi
return true;
}
mozilla::ipc::IPCResult
PluginModuleChild::RecvInitProfiler(Endpoint<mozilla::PProfilerChild>&& aEndpoint)
{
#ifdef MOZ_GECKO_PROFILER
- mProfilerController = ChildProfilerController::Create(Move(aEndpoint));
+ mProfilerController = ChildProfilerController::Create(std::move(aEndpoint));
#endif
return IPC_OK();
}
mozilla::ipc::IPCResult
PluginModuleChild::RecvDisableFlashProtectedMode()
{
MOZ_ASSERT(mIsChrome);
@@ -725,28 +725,28 @@ PluginModuleChild::RecvSetAudioSessionDa
mozilla::widget::StartAudioSession();
return IPC_OK();
#endif
}
mozilla::ipc::IPCResult
PluginModuleChild::RecvInitPluginModuleChild(Endpoint<PPluginModuleChild>&& aEndpoint)
{
- if (!CreateForContentProcess(Move(aEndpoint))) {
+ if (!CreateForContentProcess(std::move(aEndpoint))) {
return IPC_FAIL(this, "CreateForContentProcess failed");
}
return IPC_OK();
}
mozilla::ipc::IPCResult
PluginModuleChild::RecvInitPluginFunctionBroker(Endpoint<PFunctionBrokerChild>&& aEndpoint)
{
#if defined(XP_WIN)
MOZ_ASSERT(mIsChrome);
- if (!FunctionBrokerChild::Initialize(Move(aEndpoint))) {
+ if (!FunctionBrokerChild::Initialize(std::move(aEndpoint))) {
return IPC_FAIL(this,
"InitPluginFunctionBroker failed to initialize broker child.");
}
return IPC_OK();
#else
return IPC_FAIL(this, "InitPluginFunctionBroker not supported on this platform.");
#endif
}
--- a/dom/plugins/ipc/PluginModuleParent.cpp
+++ b/dom/plugins/ipc/PluginModuleParent.cpp
@@ -113,19 +113,19 @@ mozilla::plugins::SetupBridge(uint32_t a
*rv = PPluginModule::CreateEndpoints(aContentParent->OtherPid(),
chromeParent->OtherPid(),
&parent, &child);
if (NS_FAILED(*rv)) {
return true;
}
- *aEndpoint = Move(parent);
-
- if (!chromeParent->SendInitPluginModuleChild(Move(child))) {
+ *aEndpoint = std::move(parent);
+
+ if (!chromeParent->SendInitPluginModuleChild(std::move(child))) {
*rv = NS_ERROR_BRIDGE_OPEN_CHILD;
return true;
}
return true;
}
#ifdef MOZ_CRASHREPORTER_INJECTOR
@@ -359,17 +359,17 @@ mozilla::plugins::TakeFullMinidump(uint3
bool aAsync)
{
PluginModuleChromeParent* chromeParent =
PluginModuleChromeParentForId(aPluginId);
if (chromeParent) {
chromeParent->TakeFullMinidump(aContentProcessId,
aBrowserDumpId,
- Move(aCallback),
+ std::move(aCallback),
aAsync);
} else {
aCallback(EmptyString());
}
}
void
mozilla::plugins::TerminatePlugin(uint32_t aPluginId,
@@ -381,17 +381,17 @@ mozilla::plugins::TerminatePlugin(uint32
PluginModuleChromeParent* chromeParent =
PluginModuleChromeParentForId(aPluginId);
if (chromeParent) {
chromeParent->TerminateChildProcess(MessageLoop::current(),
aContentProcessId,
aMonitorDescription,
aDumpId,
- Move(aCallback),
+ std::move(aCallback),
true); // Always runs asynchronously.
} else {
aCallback(true);
}
}
/* static */ PluginLibrary*
PluginModuleContentParent::LoadModule(uint32_t aPluginId,
@@ -412,17 +412,17 @@ PluginModuleContentParent::LoadModule(ui
dom::ContentChild* cp = dom::ContentChild::GetSingleton();
nsresult rv;
uint32_t runID;
Endpoint<PPluginModuleParent> endpoint;
if (!cp->SendLoadPlugin(aPluginId, &rv, &runID, &endpoint) ||
NS_FAILED(rv)) {
return nullptr;
}
- Initialize(Move(endpoint));
+ Initialize(std::move(endpoint));
PluginModuleContentParent* parent = mapping->GetModule();
MOZ_ASSERT(parent);
if (!mapping->IsChannelOpened()) {
// mapping is linked into PluginModuleMapping::sModuleListHead and is
// needed later, so since this function is returning successfully we
// forget it here.
@@ -468,17 +468,17 @@ PluginModuleChromeParent::LoadModule(con
nsPluginTag* aPluginTag)
{
PLUGIN_LOG_DEBUG_FUNCTION;
nsAutoPtr<PluginModuleChromeParent> parent(
new PluginModuleChromeParent(aFilePath, aPluginId,
aPluginTag->mSandboxLevel));
UniquePtr<LaunchCompleteTask> onLaunchedRunnable(new LaunchedTask(parent));
- bool launched = parent->mSubprocess->Launch(Move(onLaunchedRunnable),
+ bool launched = parent->mSubprocess->Launch(std::move(onLaunchedRunnable),
aPluginTag->mSandboxLevel,
aPluginTag->mIsSandboxLoggingEnabled);
if (!launched) {
// We never reached open
parent->mShutdown = true;
return nullptr;
}
parent->mIsFlashPlugin = aPluginTag->mIsFlashPlugin;
@@ -497,19 +497,19 @@ PluginModuleChromeParent::LoadModule(con
rv = PFunctionBroker::CreateEndpoints(base::GetCurrentProcId(), parent->OtherPid(),
&brokerParentEnd, &brokerChildEnd);
if (NS_FAILED(rv)) {
parent->mShutdown = true;
return nullptr;
}
parent->mBrokerParent =
- FunctionBrokerParent::Create(Move(brokerParentEnd));
+ FunctionBrokerParent::Create(std::move(brokerParentEnd));
if (parent->mBrokerParent) {
- parent->SendInitPluginFunctionBroker(Move(brokerChildEnd));
+ parent->SendInitPluginFunctionBroker(std::move(brokerChildEnd));
}
#endif
return parent.forget();
}
void
PluginModuleChromeParent::OnProcessLaunched(const bool aSucceeded)
{
@@ -1083,17 +1083,17 @@ PluginModuleChromeParent::TakeFullMinidu
bool aAsync)
{
mozilla::MutexAutoLock lock(mCrashReporterMutex);
if (!mCrashReporter || !mTakeFullMinidumpCallback.IsEmpty()) {
aCallback(EmptyString());
return;
}
- mTakeFullMinidumpCallback.Init(Move(aCallback), aAsync);
+ mTakeFullMinidumpCallback.Init(std::move(aCallback), aAsync);
nsString browserDumpId{aBrowserDumpId};
// Check to see if we already have a browser dump id - with e10s plugin
// hangs we take this earlier (see ProcessHangMonitor) from a background
// thread. We do this before we message the main thread about the hang
// since the posted message will trash our browser stack state.
if (CrashReporter::GetMinidumpForID(aBrowserDumpId,
@@ -1116,17 +1116,17 @@ PluginModuleChromeParent::TakeFullMinidu
}
this->ReleasePluginRef();
};
// We have a single browser report, generate a new plugin process parent
// report and pair it up with the browser report handed in.
mCrashReporter->GenerateMinidumpAndPair(Process(), mBrowserDumpFile,
NS_LITERAL_CSTRING("browser"),
- Move(callback), aAsync);
+ std::move(callback), aAsync);
} else {
TakeBrowserAndPluginMinidumps(false, aContentPid, browserDumpId, aAsync);
}
}
void
PluginModuleChromeParent::RetainPluginRef()
{
@@ -1187,17 +1187,17 @@ PluginModuleChromeParent::TakeBrowserAnd
this->OnTakeFullMinidumpComplete(aResult,
aContentPid,
browserDumpId);
this->ReleasePluginRef();
};
mCrashReporter->GenerateMinidumpAndPair(Process(),
nullptr, // Pair with a dump of this process and thread.
NS_LITERAL_CSTRING("browser"),
- Move(callback),
+ std::move(callback),
aAsync);
} else {
OnTakeFullMinidumpComplete(aReportsReady, aContentPid, aBrowserDumpId);
}
}
void
PluginModuleChromeParent::OnTakeFullMinidumpComplete(bool aReportsReady,
@@ -1252,17 +1252,17 @@ PluginModuleChromeParent::TerminateChild
const nsAString& aDumpId,
std::function<void(bool)>&& aCallback,
bool aAsync)
{
if (!mTerminateChildProcessCallback.IsEmpty()) {
aCallback(false);
return;
}
- mTerminateChildProcessCallback.Init(Move(aCallback), aAsync);
+ mTerminateChildProcessCallback.Init(std::move(aCallback), aAsync);
// Start by taking a full minidump if necessary, this is done early
// because it also needs to lock the mCrashReporterMutex and Mutex doesn't
// support recursive locking.
if (aDumpId.IsEmpty()) {
RetainPluginRef();
std::function<void(nsString)> callback =
@@ -1274,17 +1274,17 @@ PluginModuleChromeParent::TerminateChild
aMonitorDescription);
if (aAsync) {
this->mCrashReporterMutex.Unlock();
}
this->ReleasePluginRef();
};
- TakeFullMinidump(aContentPid, EmptyString(), Move(callback), aAsync);
+ TakeFullMinidump(aContentPid, EmptyString(), std::move(callback), aAsync);
} else {
TerminateChildProcessOnDumpComplete(aMsgLoop, aMonitorDescription);
}
}
void
PluginModuleChromeParent::TerminateChildProcessOnDumpComplete(MessageLoop* aMsgLoop,
const nsCString& aMonitorDescription)
--- a/dom/plugins/ipc/PluginProcessParent.cpp
+++ b/dom/plugins/ipc/PluginProcessParent.cpp
@@ -70,17 +70,17 @@ PluginProcessParent::Launch(mozilla::Uni
#endif // XP_WIN
#else
if (aSandboxLevel != 0) {
MOZ_ASSERT(false,
"Can't enable an NPAPI process sandbox for platform/build.");
}
#endif
- mLaunchCompleteTask = mozilla::Move(aLaunchCompleteTask);
+ mLaunchCompleteTask = std::move(aLaunchCompleteTask);
vector<string> args;
args.push_back(MungePluginDsoPath(mPluginFilePath));
#if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
if (aSandboxLevel > 0) {
args.push_back("-flashSandboxLevel");
args.push_back(std::to_string(aSandboxLevel));
--- a/dom/presentation/PresentationAvailability.cpp
+++ b/dom/presentation/PresentationAvailability.cpp
@@ -190,17 +190,17 @@ PresentationAvailability::UpdateAvailabi
PRES_DEBUG("%s\n", __func__);
bool isChanged = (aIsAvailable != mIsAvailable);
mIsAvailable = aIsAvailable;
if (!mPromises.IsEmpty()) {
// Use the first availability change notification to resolve promise.
do {
- nsTArray<RefPtr<Promise>> promises = Move(mPromises);
+ nsTArray<RefPtr<Promise>> promises = std::move(mPromises);
if (nsContentUtils::ShouldResistFingerprinting()) {
continue;
}
for (auto& promise : promises) {
promise->MaybeResolve(this);
}
--- a/dom/presentation/PresentationRequest.cpp
+++ b/dom/presentation/PresentationRequest.cpp
@@ -104,24 +104,24 @@ PresentationRequest::Constructor(const G
aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
return nullptr;
}
urls.AppendElement(absoluteUrl);
}
RefPtr<PresentationRequest> request =
- new PresentationRequest(window, Move(urls));
+ new PresentationRequest(window, std::move(urls));
return NS_WARN_IF(!request->Init()) ? nullptr : request.forget();
}
PresentationRequest::PresentationRequest(nsPIDOMWindowInner* aWindow,
nsTArray<nsString>&& aUrls)
: DOMEventTargetHelper(aWindow)
- , mUrls(Move(aUrls))
+ , mUrls(std::move(aUrls))
{
}
PresentationRequest::~PresentationRequest()
{
}
bool
--- a/dom/push/PushManager.cpp
+++ b/dom/push/PushManager.cpp
@@ -147,37 +147,37 @@ public:
already_AddRefed<PromiseWorkerProxy>&& aProxy,
nsresult aStatus,
const nsAString& aEndpoint,
const nsAString& aScope,
nsTArray<uint8_t>&& aRawP256dhKey,
nsTArray<uint8_t>&& aAuthSecret,
nsTArray<uint8_t>&& aAppServerKey)
: WorkerRunnable(aWorkerPrivate)
- , mProxy(Move(aProxy))
+ , mProxy(std::move(aProxy))
, mStatus(aStatus)
, mEndpoint(aEndpoint)
, mScope(aScope)
- , mRawP256dhKey(Move(aRawP256dhKey))
- , mAuthSecret(Move(aAuthSecret))
- , mAppServerKey(Move(aAppServerKey))
+ , mRawP256dhKey(std::move(aRawP256dhKey))
+ , mAuthSecret(std::move(aAuthSecret))
+ , mAppServerKey(std::move(aAppServerKey))
{ }
bool
WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
{
RefPtr<Promise> promise = mProxy->WorkerPromise();
if (NS_SUCCEEDED(mStatus)) {
if (mEndpoint.IsEmpty()) {
promise->MaybeResolve(JS::NullHandleValue);
} else {
RefPtr<PushSubscription> sub =
new PushSubscription(nullptr, mEndpoint, mScope,
- Move(mRawP256dhKey), Move(mAuthSecret),
- Move(mAppServerKey));
+ std::move(mRawP256dhKey), std::move(mAuthSecret),
+ std::move(mAppServerKey));
promise->MaybeResolve(sub);
}
} else if (NS_ERROR_GET_MODULE(mStatus) == NS_ERROR_MODULE_DOM_PUSH ) {
promise->MaybeReject(mStatus);
} else {
promise->MaybeReject(NS_ERROR_DOM_PUSH_ABORT_ERR);
}
@@ -230,19 +230,19 @@ public:
WorkerPrivate* worker = mProxy->GetWorkerPrivate();
RefPtr<GetSubscriptionResultRunnable> r =
new GetSubscriptionResultRunnable(worker,
mProxy.forget(),
aStatus,
endpoint,
mScope,
- Move(rawP256dhKey),
- Move(authSecret),
- Move(appServerKey));
+ std::move(rawP256dhKey),
+ std::move(authSecret),
+ std::move(appServerKey));
MOZ_ALWAYS_TRUE(r->Dispatch());
return NS_OK;
}
// Convenience method for use in this file.
void
OnPushSubscriptionError(nsresult aStatus)
@@ -268,17 +268,17 @@ public:
GetSubscriptionRunnable(PromiseWorkerProxy* aProxy,
const nsAString& aScope,
PushManager::SubscriptionAction aAction,
nsTArray<uint8_t>&& aAppServerKey)
: Runnable("dom::GetSubscriptionRunnable")
, mProxy(aProxy)
, mScope(aScope)
, mAction(aAction)
- , mAppServerKey(Move(aAppServerKey))
+ , mAppServerKey(std::move(aAppServerKey))
{}
NS_IMETHOD
Run() override
{
AssertIsOnMainThread();
nsCOMPtr<nsIPrincipal> principal;
@@ -584,17 +584,17 @@ PushManager::PerformSubscriptionActionFr
appServerKey);
if (NS_FAILED(rv)) {
p->MaybeReject(rv);
return p.forget();
}
}
RefPtr<GetSubscriptionRunnable> r =
- new GetSubscriptionRunnable(proxy, mScope, aAction, Move(appServerKey));
+ new GetSubscriptionRunnable(proxy, mScope, aAction, std::move(appServerKey));
MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(r));
return p.forget();
}
nsresult
PushManager::NormalizeAppServerKey(const OwningArrayBufferViewOrArrayBufferOrString& aSource,
nsTArray<uint8_t>& aAppServerKey)
--- a/dom/push/PushSubscription.cpp
+++ b/dom/push/PushSubscription.cpp
@@ -60,17 +60,17 @@ NS_IMPL_ISUPPORTS(UnsubscribeResultCallb
class UnsubscribeResultRunnable final : public WorkerRunnable
{
public:
UnsubscribeResultRunnable(WorkerPrivate* aWorkerPrivate,
already_AddRefed<PromiseWorkerProxy>&& aProxy,
nsresult aStatus,
bool aSuccess)
: WorkerRunnable(aWorkerPrivate)
- , mProxy(Move(aProxy))
+ , mProxy(std::move(aProxy))
, mStatus(aStatus)
, mSuccess(aSuccess)
{
AssertIsOnMainThread();
}
bool
WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
@@ -198,31 +198,31 @@ private:
PushSubscription::PushSubscription(nsIGlobalObject* aGlobal,
const nsAString& aEndpoint,
const nsAString& aScope,
nsTArray<uint8_t>&& aRawP256dhKey,
nsTArray<uint8_t>&& aAuthSecret,
nsTArray<uint8_t>&& aAppServerKey)
: mEndpoint(aEndpoint)
, mScope(aScope)
- , mRawP256dhKey(Move(aRawP256dhKey))
- , mAuthSecret(Move(aAuthSecret))
+ , mRawP256dhKey(std::move(aRawP256dhKey))
+ , mAuthSecret(std::move(aAuthSecret))
{
if (NS_IsMainThread()) {
mGlobal = aGlobal;
} else {
#ifdef DEBUG
// There's only one global on a worker, so we don't need to pass a global
// object to the constructor.
WorkerPrivate* worker = GetCurrentThreadWorkerPrivate();
MOZ_ASSERT(worker);
worker->AssertIsOnWorkerThread();
#endif
}
- mOptions = new PushSubscriptionOptions(mGlobal, Move(aAppServerKey));
+ mOptions = new PushSubscriptionOptions(mGlobal, std::move(aAppServerKey));
}
PushSubscription::~PushSubscription()
{}
NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(PushSubscription, mGlobal, mOptions)
NS_IMPL_CYCLE_COLLECTING_ADDREF(PushSubscription)
NS_IMPL_CYCLE_COLLECTING_RELEASE(PushSubscription)
@@ -272,19 +272,19 @@ PushSubscription::Constructor(GlobalObje
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
return nullptr;
}
}
RefPtr<PushSubscription> sub = new PushSubscription(global,
aInitDict.mEndpoint,
aInitDict.mScope,
- Move(rawKey),
- Move(authSecret),
- Move(appServerKey));
+ std::move(rawKey),
+ std::move(authSecret),
+ std::move(appServerKey));
return sub.forget();
}
already_AddRefed<Promise>
PushSubscription::Unsubscribe(ErrorResult& aRv)
{
if (!NS_IsMainThread()) {
--- a/dom/push/PushSubscriptionOptions.cpp
+++ b/dom/push/PushSubscriptionOptions.cpp
@@ -10,17 +10,17 @@
#include "mozilla/HoldDropJSObjects.h"
namespace mozilla {
namespace dom {
PushSubscriptionOptions::PushSubscriptionOptions(nsIGlobalObject* aGlobal,
nsTArray<uint8_t>&& aRawAppServerKey)
: mGlobal(aGlobal)
- , mRawAppServerKey(Move(aRawAppServerKey))
+ , mRawAppServerKey(std::move(aRawAppServerKey))
, mAppServerKey(nullptr)
{
// There's only one global on a worker, so we don't need to pass a global
// object to the constructor.
MOZ_ASSERT_IF(NS_IsMainThread(), mGlobal);
mozilla::HoldJSObjects(this);
}
--- a/dom/quota/ActorsParent.cpp
+++ b/dom/quota/ActorsParent.cpp
@@ -7863,17 +7863,17 @@ StorageDirectoryHelper::GetDirectoryMeta
bool value;
if (NS_SUCCEEDED(binaryStream->ReadBoolean(&value))) {
isApp.SetValue(value);
}
aTimestamp = timestamp;
aGroup = group;
aOrigin = origin;
- aIsApp = Move(isApp);
+ aIsApp = std::move(isApp);
return NS_OK;
}
nsresult
StorageDirectoryHelper::GetDirectoryMetadata2(nsIFile* aDirectory,
int64_t& aTimestamp,
nsACString& aSuffix,
nsACString& aGroup,
@@ -8599,17 +8599,17 @@ CreateOrUpgradeDirectoryMetadataHelper::
originProps.mIgnore = true;
}
}
else {
bool persistent = QuotaManager::IsOriginInternal(originProps.mSpec);
originProps.mTimestamp = GetLastModifiedTime(originDir, persistent);
}
- mOriginProps.AppendElement(Move(originProps));
+ mOriginProps.AppendElement(std::move(originProps));
}
if (mOriginProps.IsEmpty()) {
return NS_OK;
}
rv = ProcessOriginDirectories();
if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -8886,17 +8886,17 @@ UpgradeStorageFrom0_0To1_0Helper::DoUpgr
isApp);
if (NS_FAILED(rv) || isApp.IsNull()) {
originProps.mTimestamp = GetLastModifiedTime(originDir, mPersistent);
originProps.mNeedsRestore = true;
} else {
originProps.mTimestamp = timestamp;
}
- mOriginProps.AppendElement(Move(originProps));
+ mOriginProps.AppendElement(std::move(originProps));
}
if (mOriginProps.IsEmpty()) {
return NS_OK;
}
rv = ProcessOriginDirectories();
if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -9035,17 +9035,17 @@ UpgradeStorageFrom1_0To2_0Helper::DoUpgr
isApp.SetValue());
if (NS_FAILED(rv)) {
originProps.mTimestamp = GetLastModifiedTime(originDir, mPersistent);
originProps.mNeedsRestore2 = true;
} else {
originProps.mTimestamp = timestamp;
}
- mOriginProps.AppendElement(Move(originProps));
+ mOriginProps.AppendElement(std::move(originProps));
}
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
if (mOriginProps.IsEmpty()) {
return NS_OK;
}
@@ -9345,17 +9345,17 @@ UpgradeStorageFrom2_0To2_1Helper::DoUpgr
isApp.SetValue());
if (NS_FAILED(rv)) {
originProps.mTimestamp = GetLastModifiedTime(originDir, mPersistent);
originProps.mNeedsRestore2 = true;
} else {
originProps.mTimestamp = timestamp;
}
- mOriginProps.AppendElement(Move(originProps));
+ mOriginProps.AppendElement(std::move(originProps));
}
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
if (mOriginProps.IsEmpty()) {
return NS_OK;
}
@@ -9474,17 +9474,17 @@ RestoreDirectoryMetadata2Helper::Restore
OriginProps originProps;
rv = originProps.Init(mDirectory);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
originProps.mTimestamp = GetLastModifiedTime(mDirectory, mPersistent);
- mOriginProps.AppendElement(Move(originProps));
+ mOriginProps.AppendElement(std::move(originProps));
rv = ProcessOriginDirectories();
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
return NS_OK;
}
--- a/dom/script/ScriptLoader.cpp
+++ b/dom/script/ScriptLoader.cpp
@@ -1376,17 +1376,17 @@ ScriptLoader::ProcessExternalScript(nsIS
if (!principal) {
principal = aScriptContent->NodePrincipal();
}
CORSMode ourCORSMode = aElement->GetCORSMode();
mozilla::net::ReferrerPolicy ourRefPolicy = mDocument->GetReferrerPolicy();
request = CreateLoadRequest(aScriptKind, scriptURI, aElement,
ourCORSMode, sriMetadata, ourRefPolicy);
- request->mTriggeringPrincipal = Move(principal);
+ request->mTriggeringPrincipal = std::move(principal);
request->mIsInline = false;
request->SetScriptMode(aElement->GetScriptDeferred(),
aElement->GetScriptAsync());
// keep request->mScriptFromHead to false so we don't treat non preloaded
// scripts as blockers for full page load. See bug 792438.
LOG(("ScriptLoadRequest (%p): Created request for external script",
request.get()));
--- a/dom/security/nsCSPUtils.cpp
+++ b/dom/security/nsCSPUtils.cpp
@@ -1111,108 +1111,108 @@ nsCSPDirective::toDomCSPStruct(mozilla::
src.Truncate();
mSrcs[i]->toString(src);
srcs.AppendElement(src, mozilla::fallible);
}
switch(mDirective) {
case nsIContentSecurityPolicy::DEFAULT_SRC_DIRECTIVE:
outCSP.mDefault_src.Construct();
- outCSP.mDefault_src.Value() = mozilla::Move(srcs);
+ outCSP.mDefault_src.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::SCRIPT_SRC_DIRECTIVE:
outCSP.mScript_src.Construct();
- outCSP.mScript_src.Value() = mozilla::Move(srcs);
+ outCSP.mScript_src.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::OBJECT_SRC_DIRECTIVE:
outCSP.mObject_src.Construct();
- outCSP.mObject_src.Value() = mozilla::Move(srcs);
+ outCSP.mObject_src.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::STYLE_SRC_DIRECTIVE:
outCSP.mStyle_src.Construct();
- outCSP.mStyle_src.Value() = mozilla::Move(srcs);
+ outCSP.mStyle_src.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::IMG_SRC_DIRECTIVE:
outCSP.mImg_src.Construct();
- outCSP.mImg_src.Value() = mozilla::Move(srcs);
+ outCSP.mImg_src.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::MEDIA_SRC_DIRECTIVE:
outCSP.mMedia_src.Construct();
- outCSP.mMedia_src.Value() = mozilla::Move(srcs);
+ outCSP.mMedia_src.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::FRAME_SRC_DIRECTIVE:
outCSP.mFrame_src.Construct();
- outCSP.mFrame_src.Value() = mozilla::Move(srcs);
+ outCSP.mFrame_src.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::FONT_SRC_DIRECTIVE:
outCSP.mFont_src.Construct();
- outCSP.mFont_src.Value() = mozilla::Move(srcs);
+ outCSP.mFont_src.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::CONNECT_SRC_DIRECTIVE:
outCSP.mConnect_src.Construct();
- outCSP.mConnect_src.Value() = mozilla::Move(srcs);
+ outCSP.mConnect_src.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::REPORT_URI_DIRECTIVE:
outCSP.mReport_uri.Construct();
- outCSP.mReport_uri.Value() = mozilla::Move(srcs);
+ outCSP.mReport_uri.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::FRAME_ANCESTORS_DIRECTIVE:
outCSP.mFrame_ancestors.Construct();
- outCSP.mFrame_ancestors.Value() = mozilla::Move(srcs);
+ outCSP.mFrame_ancestors.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::WEB_MANIFEST_SRC_DIRECTIVE:
outCSP.mManifest_src.Construct();
- outCSP.mManifest_src.Value() = mozilla::Move(srcs);
+ outCSP.mManifest_src.Value() = std::move(srcs);
return;
// not supporting REFLECTED_XSS_DIRECTIVE
case nsIContentSecurityPolicy::BASE_URI_DIRECTIVE:
outCSP.mBase_uri.Construct();
- outCSP.mBase_uri.Value() = mozilla::Move(srcs);
+ outCSP.mBase_uri.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::FORM_ACTION_DIRECTIVE:
outCSP.mForm_action.Construct();
- outCSP.mForm_action.Value() = mozilla::Move(srcs);
+ outCSP.mForm_action.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::BLOCK_ALL_MIXED_CONTENT:
outCSP.mBlock_all_mixed_content.Construct();
// does not have any srcs
return;
case nsIContentSecurityPolicy::UPGRADE_IF_INSECURE_DIRECTIVE:
outCSP.mUpgrade_insecure_requests.Construct();
// does not have any srcs
return;
case nsIContentSecurityPolicy::CHILD_SRC_DIRECTIVE:
outCSP.mChild_src.Construct();
- outCSP.mChild_src.Value() = mozilla::Move(srcs);
+ outCSP.mChild_src.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::SANDBOX_DIRECTIVE:
outCSP.mSandbox.Construct();
- outCSP.mSandbox.Value() = mozilla::Move(srcs);
+ outCSP.mSandbox.Value() = std::move(srcs);
return;
case nsIContentSecurityPolicy::WORKER_SRC_DIRECTIVE:
outCSP.mWorker_src.Construct();
- outCSP.mWorker_src.Value() = mozilla::Move(srcs);
+ outCSP.mWorker_src.Value() = std::move(srcs);
return;
// REQUIRE_SRI_FOR is handled in nsCSPPolicy::toDomCSPStruct()
default:
NS_ASSERTION(false, "cannot find directive to convert CSP to JSON");
}
}
--- a/dom/serviceworkers/ServiceWorker.cpp
+++ b/dom/serviceworkers/ServiceWorker.cpp
@@ -180,17 +180,17 @@ ServiceWorker::PostMessage(JSContext* aC
}
ipc::StructuredCloneData data;
data.Write(aCx, aMessage, transferable, aRv);
if (aRv.Failed()) {
return;
}
- mInner->PostMessage(Move(data), clientInfo.ref(), clientState.ref());
+ mInner->PostMessage(std::move(data), clientInfo.ref(), clientState.ref());
}
const ServiceWorkerDescriptor&
ServiceWorker::Descriptor() const
{
return mDescriptor;
}
--- a/dom/serviceworkers/ServiceWorkerContainer.cpp
+++ b/dom/serviceworkers/ServiceWorkerContainer.cpp
@@ -428,17 +428,17 @@ ServiceWorkerContainer::GetRegistrations
outer->MaybeReject(rv);
return;
}
nsTArray<RefPtr<ServiceWorkerRegistration>> regList;
for (auto& desc : aDescList) {
RefPtr<ServiceWorkerRegistration> reg =
global->GetOrCreateServiceWorkerRegistration(desc);
if (reg) {
- regList.AppendElement(Move(reg));
+ regList.AppendElement(std::move(reg));
}
}
outer->MaybeResolve(regList);
}, [self, outer, holder] (const CopyableErrorResult& aRv) {
holder->Complete();
outer->MaybeReject(CopyableErrorResult(aRv));
})->Track(*holder);
--- a/dom/serviceworkers/ServiceWorkerDescriptor.cpp
+++ b/dom/serviceworkers/ServiceWorkerDescriptor.cpp
@@ -59,25 +59,25 @@ ServiceWorkerDescriptor::operator=(const
return *this;
}
mData.reset();
mData = MakeUnique<IPCServiceWorkerDescriptor>(*aRight.mData);
return *this;
}
ServiceWorkerDescriptor::ServiceWorkerDescriptor(ServiceWorkerDescriptor&& aRight)
- : mData(Move(aRight.mData))
+ : mData(std::move(aRight.mData))
{
}
ServiceWorkerDescriptor&
ServiceWorkerDescriptor::operator=(ServiceWorkerDescriptor&& aRight)
{
mData.reset();
- mData = Move(aRight.mData);
+ mData = std::move(aRight.mData);
return *this;
}
ServiceWorkerDescriptor::~ServiceWorkerDescriptor()
{
}
bool
@@ -98,17 +98,17 @@ ServiceWorkerDescriptor::PrincipalInfo()
return mData->principalInfo();
}
nsCOMPtr<nsIPrincipal>
ServiceWorkerDescriptor::GetPrincipal() const
{
AssertIsOnMainThread();
nsCOMPtr<nsIPrincipal> ref = PrincipalInfoToPrincipal(mData->principalInfo());
- return Move(ref);
+ return std::move(ref);
}
const nsCString&
ServiceWorkerDescriptor::Scope() const
{
return mData->scope();
}
--- a/dom/serviceworkers/ServiceWorkerEvents.cpp
+++ b/dom/serviceworkers/ServiceWorkerEvents.cpp
@@ -230,17 +230,17 @@ class BodyCopyHandle final : public nsII
~BodyCopyHandle()
{
}
public:
NS_DECL_THREADSAFE_ISUPPORTS
explicit BodyCopyHandle(UniquePtr<RespondWithClosure>&& aClosure)
- : mClosure(Move(aClosure))
+ : mClosure(std::move(aClosure))
{
}
NS_IMETHOD
BodyComplete(nsresult aRv) override
{
MOZ_ASSERT(NS_IsMainThread());
@@ -285,17 +285,17 @@ public:
const nsACString& aResponseURLSpec,
UniquePtr<RespondWithClosure>&& aClosure)
: Runnable("dom::StartResponse")
, mChannel(aChannel)
, mInternalResponse(aInternalResponse)
, mWorkerChannelInfo(aWorkerChannelInfo)
, mScriptSpec(aScriptSpec)
, mResponseURLSpec(aResponseURLSpec)
- , mClosure(Move(aClosure))
+ , mClosure(std::move(aClosure))
{
}
NS_IMETHOD
Run() override
{
MOZ_ASSERT(NS_IsMainThread());
@@ -361,17 +361,17 @@ public:
}
if (!body) {
mInternalResponse->GetUnfilteredBody(getter_AddRefs(body));
} else {
Telemetry::ScalarAdd(Telemetry::ScalarID::SW_ALTERNATIVE_BODY_USED_COUNT, 1);
}
RefPtr<BodyCopyHandle> copyHandle;
- copyHandle = new BodyCopyHandle(Move(mClosure));
+ copyHandle = new BodyCopyHandle(std::move(mClosure));
rv = mChannel->StartSynthesizedResponse(body, copyHandle, cacheInfoChannel,
mResponseURLSpec,
mInternalResponse->IsRedirected());
if (NS_WARN_IF(NS_FAILED(rv))) {
mChannel->CancelInterception(NS_ERROR_INTERCEPTION_FAILED);
return NS_OK;
}
@@ -737,17 +737,17 @@ RespondWithHandler::ResolvedCallback(JSC
mRespondWithLineNumber,
mRespondWithColumnNumber));
nsCOMPtr<nsIRunnable> startRunnable = new StartResponse(mInterceptedChannel,
ir,
worker->GetChannelInfo(),
mScriptSpec,
responseURL,
- Move(closure));
+ std::move(closure));
nsCOMPtr<nsIInputStream> body;
ir->GetUnfilteredBody(getter_AddRefs(body));
// Errors and redirects may not have a body.
if (body) {
ErrorResult error;
response->SetBodyUsed(aCx, error);
if (NS_WARN_IF(error.Failed())) {
@@ -1069,17 +1069,17 @@ ExtractBytesFromData(const OwningArrayBu
}
NS_NOTREACHED("Unexpected push message data");
return NS_ERROR_FAILURE;
}
}
PushMessageData::PushMessageData(nsISupports* aOwner,
nsTArray<uint8_t>&& aBytes)
- : mOwner(aOwner), mBytes(Move(aBytes)) {}
+ : mOwner(aOwner), mBytes(std::move(aBytes)) {}
PushMessageData::~PushMessageData()
{
}
NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(PushMessageData, mOwner)
NS_IMPL_CYCLE_COLLECTING_ADDREF(PushMessageData)
@@ -1188,17 +1188,17 @@ PushEvent::Constructor(mozilla::dom::Eve
e->SetComposed(aOptions.mComposed);
if(aOptions.mData.WasPassed()){
nsTArray<uint8_t> bytes;
nsresult rv = ExtractBytesFromData(aOptions.mData.Value(), bytes);
if (NS_FAILED(rv)) {
aRv.Throw(rv);
return nullptr;
}
- e->mData = new PushMessageData(aOwner, Move(bytes));
+ e->mData = new PushMessageData(aOwner, std::move(bytes));
}
return e.forget();
}
NS_IMPL_ADDREF_INHERITED(PushEvent, ExtendableEvent)
NS_IMPL_RELEASE_INHERITED(PushEvent, ExtendableEvent)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PushEvent)
--- a/dom/serviceworkers/ServiceWorkerImpl.cpp
+++ b/dom/serviceworkers/ServiceWorkerImpl.cpp
@@ -36,17 +36,17 @@ ServiceWorkerImpl::RemoveServiceWorker(S
mOuter = nullptr;
}
void
ServiceWorkerImpl::PostMessage(ipc::StructuredCloneData&& aData,
const ClientInfo& aClientInfo,
const ClientState& aClientState)
{
- mInfo->PostMessage(Move(aData), aClientInfo, aClientState);
+ mInfo->PostMessage(std::move(aData), aClientInfo, aClientState);
}
void
ServiceWorkerImpl::SetState(ServiceWorkerState aState)
{
if (!mOuter) {
return;
}
--- a/dom/serviceworkers/ServiceWorkerInfo.cpp
+++ b/dom/serviceworkers/ServiceWorkerInfo.cpp
@@ -242,17 +242,17 @@ ServiceWorkerInfo::RemoveListener(Listen
MOZ_ASSERT(removed);
}
void
ServiceWorkerInfo::PostMessage(ipc::StructuredCloneData&& aData,
const ClientInfo& aClientInfo,
const ClientState& aClientState)
{
- mServiceWorkerPrivate->SendMessageEvent(Move(aData),
+ mServiceWorkerPrivate->SendMessageEvent(std::move(aData),
ClientInfoAndState(aClientInfo.ToIPC(),
aClientState.ToIPC()));
}
void
ServiceWorkerInfo::UpdateInstalledTime()
{
MOZ_ASSERT(State() == ServiceWorkerState::Installed);
--- a/dom/serviceworkers/ServiceWorkerManager.cpp
+++ b/dom/serviceworkers/ServiceWorkerManager.cpp
@@ -319,51 +319,51 @@ ServiceWorkerManager::StartControllingCl
const ServiceWorkerDescriptor& active =
aRegistrationInfo->GetActive()->Descriptor();
auto entry = mControlledClients.LookupForAdd(aClientInfo.Id());
if (entry) {
RefPtr<ServiceWorkerRegistrationInfo> old =
entry.Data()->mRegistrationInfo.forget();
- ref = Move(entry.Data()->mClientHandle->Control(active));
+ ref = std::move(entry.Data()->mClientHandle->Control(active));
entry.Data()->mRegistrationInfo = aRegistrationInfo;
if (old != aRegistrationInfo) {
StopControllingRegistration(old);
aRegistrationInfo->StartControllingClient();
}
Telemetry::Accumulate(Telemetry::SERVICE_WORKER_CONTROLLED_DOCUMENTS, 1);
- return Move(ref);
+ return std::move(ref);
}
RefPtr<ClientHandle> clientHandle =
ClientManager::CreateHandle(aClientInfo,
SystemGroup::EventTargetFor(TaskCategory::Other));
- ref = Move(clientHandle->Control(active));
+ ref = std::move(clientHandle->Control(active));
aRegistrationInfo->StartControllingClient();
entry.OrInsert([&] {
return new ControlledClientData(clientHandle, aRegistrationInfo);
});
RefPtr<ServiceWorkerManager> self(this);
clientHandle->OnDetach()->Then(
SystemGroup::EventTargetFor(TaskCategory::Other), __func__,
- [self = Move(self), aClientInfo] {
+ [self = std::move(self), aClientInfo] {
self->StopControllingClient(aClientInfo);
});
Telemetry::Accumulate(Telemetry::SERVICE_WORKER_CONTROLLED_DOCUMENTS, 1);
- return Move(ref);
+ return std::move(ref);
}
void
ServiceWorkerManager::StopControllingClient(const ClientInfo& aClientInfo)
{
auto entry = mControlledClients.Lookup(aClientInfo.Id());
if (!entry) {
return;
@@ -432,17 +432,17 @@ class ServiceWorkerResolveWindowPromiseO
virtual void
JobFinished(ServiceWorkerJob* aJob, ErrorResult& aStatus) override
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aJob);
if (aStatus.Failed()) {
- mPromise->Reject(Move(aStatus), __func__);
+ mPromise->Reject(std::move(aStatus), __func__);
return;
}
MOZ_ASSERT(aJob->GetType() == ServiceWorkerJob::Type::Register);
RefPtr<ServiceWorkerRegisterJob> registerJob =
static_cast<ServiceWorkerRegisterJob*>(aJob);
RefPtr<ServiceWorkerRegistrationInfo> reg = registerJob->GetRegistration();
@@ -1110,55 +1110,55 @@ ServiceWorkerManager::WhenReady(const Cl
nsCOMPtr<nsISerialEventTarget> target =
SystemGroup::EventTargetFor(TaskCategory::Other);
RefPtr<ClientHandle> handle = ClientManager::CreateHandle(aClientInfo, target);
mPendingReadyList.AppendElement(MakeUnique<PendingReadyData>(handle));
RefPtr<ServiceWorkerManager> self(this);
handle->OnDetach()->Then( target, __func__,
- [self = Move(self), aClientInfo] {
+ [self = std::move(self), aClientInfo] {
self->RemovePendingReadyPromise(aClientInfo);
});
return mPendingReadyList.LastElement()->mPromise;
}
void
ServiceWorkerManager::CheckPendingReadyPromises()
{
nsTArray<UniquePtr<PendingReadyData>> pendingReadyList;
mPendingReadyList.SwapElements(pendingReadyList);
for (uint32_t i = 0; i < pendingReadyList.Length(); ++i) {
- UniquePtr<PendingReadyData> prd(Move(pendingReadyList[i]));
+ UniquePtr<PendingReadyData> prd(std::move(pendingReadyList[i]));
RefPtr<ServiceWorkerRegistrationInfo> reg =
GetServiceWorkerRegistrationInfo(prd->mClientHandle->Info());
if (reg && reg->GetActive()) {
prd->mPromise->Resolve(reg->Descriptor(), __func__);
} else {
- mPendingReadyList.AppendElement(Move(prd));
+ mPendingReadyList.AppendElement(std::move(prd));
}
}
}
void
ServiceWorkerManager::RemovePendingReadyPromise(const ClientInfo& aClientInfo)
{
nsTArray<UniquePtr<PendingReadyData>> pendingReadyList;
mPendingReadyList.SwapElements(pendingReadyList);
for (uint32_t i = 0; i < pendingReadyList.Length(); ++i) {
- UniquePtr<PendingReadyData> prd(Move(pendingReadyList[i]));
+ UniquePtr<PendingReadyData> prd(std::move(pendingReadyList[i]));
if (prd->mClientHandle->Info().Id() == aClientInfo.Id() &&
prd->mClientHandle->Info().PrincipalInfo() == aClientInfo.PrincipalInfo()) {
prd->mPromise->Reject(NS_ERROR_DOM_ABORT_ERR, __func__);
} else {
- mPendingReadyList.AppendElement(Move(prd));
+ mPendingReadyList.AppendElement(std::move(prd));
}
}
}
ServiceWorkerInfo*
ServiceWorkerManager::GetActiveWorkerInfoForScope(const OriginAttributes& aOriginAttributes,
const nsACString& aScope)
{
@@ -2213,17 +2213,17 @@ ServiceWorkerManager::DispatchFetchEvent
reservedClient ? reservedClient->EventTarget()
: SystemGroup::EventTargetFor(TaskCategory::Other);
reservedClient.reset();
reservedClient = ClientManager::CreateSource(ClientType::Window,
target,
principal);
- loadInfo->GiveReservedClientSource(Move(reservedClient));
+ loadInfo->GiveReservedClientSource(std::move(reservedClient));
clientInfo = loadInfo->GetReservedClientInfo();
}
}
// First, attempt to mark the reserved client controlled directly. This
// will update the controlled status in the ClientManagerService in the
// parent. It will also eventually propagate back to the ClientSource.
--- a/dom/serviceworkers/ServiceWorkerRegistrar.cpp
+++ b/dom/serviceworkers/ServiceWorkerRegistrar.cpp
@@ -827,17 +827,17 @@ class ServiceWorkerRegistrarSaveDataRunn
const nsTArray<ServiceWorkerRegistrationData> mData;
const uint32_t mGeneration;
public:
ServiceWorkerRegistrarSaveDataRunnable(nsTArray<ServiceWorkerRegistrationData>&& aData,
uint32_t aGeneration)
: Runnable("dom::ServiceWorkerRegistrarSaveDataRunnable")
, mEventTarget(GetCurrentThreadEventTarget())
- , mData(Move(aData))
+ , mData(std::move(aData))
, mGeneration(aGeneration)
{
AssertIsOnBackgroundThread();
MOZ_DIAGNOSTIC_ASSERT(mGeneration != kInvalidGeneration);
}
NS_IMETHOD
Run() override
@@ -883,17 +883,17 @@ ServiceWorkerRegistrar::MaybeScheduleSav
{
MonitorAutoLock lock(mMonitor);
generation = mDataGeneration;
data.AppendElements(mData);
}
RefPtr<Runnable> runnable =
- new ServiceWorkerRegistrarSaveDataRunnable(Move(data), generation);
+ new ServiceWorkerRegistrarSaveDataRunnable(std::move(data), generation);
nsresult rv = target->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
NS_ENSURE_SUCCESS_VOID(rv);
mRunnableDispatched = true;
}
void
ServiceWorkerRegistrar::ShutdownCompleted()
@@ -1276,17 +1276,17 @@ ServiceWorkerRegistrar::GetShutdownPhase
// memory), and there's no point in continuing startup. Include as much
// information as possible in the crash report.
RELEASE_ASSERT_SUCCEEDED(rv, "async shutdown service");
nsCOMPtr<nsIAsyncShutdownClient> client;
rv = svc->GetProfileBeforeChange(getter_AddRefs(client));
RELEASE_ASSERT_SUCCEEDED(rv, "profileBeforeChange shutdown blocker");
- return Move(client);
+ return std::move(client);
}
#undef RELEASE_ASSERT_SUCCEEDED
void
ServiceWorkerRegistrar::Shutdown()
{
AssertIsOnBackgroundThread();
--- a/dom/serviceworkers/ServiceWorkerRegistrationDescriptor.cpp
+++ b/dom/serviceworkers/ServiceWorkerRegistrationDescriptor.cpp
@@ -22,17 +22,17 @@ ServiceWorkerRegistrationDescriptor::New
Maybe<IPCServiceWorkerDescriptor> result;
if (mData->installing().type() != OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
result.emplace(mData->installing().get_IPCServiceWorkerDescriptor());
} else if (mData->waiting().type() != OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
result.emplace(mData->waiting().get_IPCServiceWorkerDescriptor());
} else if (mData->active().type() != OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
result.emplace(mData->active().get_IPCServiceWorkerDescriptor());
}
- return Move(result);
+ return std::move(result);
}
ServiceWorkerRegistrationDescriptor::ServiceWorkerRegistrationDescriptor(
uint64_t aId,
nsIPrincipal* aPrincipal,
const nsACString& aScope,
ServiceWorkerUpdateViaCache aUpdateViaCache)
: mData(MakeUnique<IPCServiceWorkerRegistrationDescriptor>())
@@ -85,26 +85,26 @@ ServiceWorkerRegistrationDescriptor::ope
}
mData.reset();
mData = MakeUnique<IPCServiceWorkerRegistrationDescriptor>(*aRight.mData);
MOZ_DIAGNOSTIC_ASSERT(IsValid());
return *this;
}
ServiceWorkerRegistrationDescriptor::ServiceWorkerRegistrationDescriptor(ServiceWorkerRegistrationDescriptor&& aRight)
- : mData(Move(aRight.mData))
+ : mData(std::move(aRight.mData))
{
MOZ_DIAGNOSTIC_ASSERT(IsValid());
}
ServiceWorkerRegistrationDescriptor&
ServiceWorkerRegistrationDescriptor::operator=(ServiceWorkerRegistrationDescriptor&& aRight)
{
mData.reset();
- mData = Move(aRight.mData);
+ mData = std::move(aRight.mData);
MOZ_DIAGNOSTIC_ASSERT(IsValid());
return *this;
}
ServiceWorkerRegistrationDescriptor::~ServiceWorkerRegistrationDescriptor()
{
// Non-default destructor to avoid exposing the IPC type in the header.
}
@@ -133,17 +133,17 @@ ServiceWorkerRegistrationDescriptor::Pri
return mData->principalInfo();
}
nsCOMPtr<nsIPrincipal>
ServiceWorkerRegistrationDescriptor::GetPrincipal() const
{
AssertIsOnMainThread();
nsCOMPtr<nsIPrincipal> ref = PrincipalInfoToPrincipal(mData->principalInfo());
- return Move(ref);
+ return std::move(ref);
}
const nsCString&
ServiceWorkerRegistrationDescriptor::Scope() const
{
return mData->scope();
}
@@ -152,54 +152,54 @@ ServiceWorkerRegistrationDescriptor::Get
{
Maybe<ServiceWorkerDescriptor> result;
if (mData->installing().type() != OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
result.emplace(ServiceWorkerDescriptor(
mData->installing().get_IPCServiceWorkerDescriptor()));
}
- return Move(result);
+ return std::move(result);
}
Maybe<ServiceWorkerDescriptor>
ServiceWorkerRegistrationDescriptor::GetWaiting() const
{
Maybe<ServiceWorkerDescriptor> result;
if (mData->waiting().type() != OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
result.emplace(ServiceWorkerDescriptor(
mData->waiting().get_IPCServiceWorkerDescriptor()));
}
- return Move(result);
+ return std::move(result);
}
Maybe<ServiceWorkerDescriptor>
ServiceWorkerRegistrationDescriptor::GetActive() const
{
Maybe<ServiceWorkerDescriptor> result;
if (mData->active().type() != OptionalIPCServiceWorkerDescriptor::Tvoid_t) {
result.emplace(ServiceWorkerDescriptor(
mData->active().get_IPCServiceWorkerDescriptor()));
}
- return Move(result);
+ return std::move(result);
}
Maybe<ServiceWorkerDescriptor>
ServiceWorkerRegistrationDescriptor::Newest() const
{
Maybe<ServiceWorkerDescriptor> result;
Maybe<IPCServiceWorkerDescriptor> newest(NewestInternal());
if (newest.isSome()) {
result.emplace(ServiceWorkerDescriptor(newest.ref()));
}
- return Move(result);
+ return std::move(result);
}
namespace {
bool
IsValidWorker(const OptionalIPCServiceWorkerDescriptor& aWorker,
const nsACString& aScope,
const mozilla::ipc::ContentPrincipalInfo& aContentPrincipal)
--- a/dom/serviceworkers/ServiceWorkerRegistrationImpl.cpp
+++ b/dom/serviceworkers/ServiceWorkerRegistrationImpl.cpp
@@ -185,17 +185,17 @@ public:
UpdateSucceeded(ServiceWorkerRegistrationInfo* aRegistration) override
{
mPromise->Resolve(aRegistration->Descriptor(), __func__);
}
void
UpdateFailed(ErrorResult& aStatus) override
{
- mPromise->Reject(Move(aStatus), __func__);
+ mPromise->Reject(std::move(aStatus), __func__);
}
RefPtr<ServiceWorkerRegistrationPromise>
Promise() const
{
return mPromise;
}
};
@@ -205,33 +205,33 @@ class WorkerThreadUpdateCallback final :
RefPtr<ThreadSafeWorkerRef> mWorkerRef;
RefPtr<ServiceWorkerRegistrationPromise::Private> mPromise;
~WorkerThreadUpdateCallback() = default;
public:
WorkerThreadUpdateCallback(RefPtr<ThreadSafeWorkerRef>&& aWorkerRef,
ServiceWorkerRegistrationPromise::Private* aPromise)
- : mWorkerRef(Move(aWorkerRef))
+ : mWorkerRef(std::move(aWorkerRef))
, mPromise(aPromise)
{
MOZ_ASSERT(NS_IsMainThread());
}
void
UpdateSucceeded(ServiceWorkerRegistrationInfo* aRegistration) override
{
mPromise->Resolve(aRegistration->Descriptor(), __func__);
mWorkerRef = nullptr;
}
void
UpdateFailed(ErrorResult& aStatus) override
{
- mPromise->Reject(Move(aStatus), __func__);
+ mPromise->Reject(std::move(aStatus), __func__);
mWorkerRef = nullptr;
}
};
class SWRUpdateRunnable final : public Runnable
{
class TimerCallback final : public nsITimerCallback
{
@@ -340,17 +340,17 @@ public:
RefPtr<ServiceWorkerRegistrationPromise::Private> promise;
{
MutexAutoLock lock(mMutex);
promise.swap(mPromise);
}
RefPtr<WorkerThreadUpdateCallback> cb =
- new WorkerThreadUpdateCallback(Move(mWorkerRef), promise);
+ new WorkerThreadUpdateCallback(std::move(mWorkerRef), promise);
UpdateInternal(principal, mDescriptor.Scope(), cb);
return NS_OK;
}
private:
~SWRUpdateRunnable()
{
@@ -413,18 +413,18 @@ class WorkerUnregisterCallback final : p
{
RefPtr<ThreadSafeWorkerRef> mWorkerRef;
RefPtr<GenericPromise::Private> mPromise;
public:
NS_DECL_ISUPPORTS
WorkerUnregisterCallback(RefPtr<ThreadSafeWorkerRef>&& aWorkerRef,
RefPtr<GenericPromise::Private>&& aPromise)
- : mWorkerRef(Move(aWorkerRef))
- , mPromise(Move(aPromise))
+ : mWorkerRef(std::move(aWorkerRef))
+ , mPromise(std::move(aPromise))
{
MOZ_DIAGNOSTIC_ASSERT(mWorkerRef);
MOZ_DIAGNOSTIC_ASSERT(mPromise);
}
NS_IMETHOD
UnregisterSucceeded(bool aState) override
{
@@ -502,17 +502,17 @@ public:
RefPtr<GenericPromise::Private> promise;
{
MutexAutoLock lock(mMutex);
promise = mPromise.forget();
}
RefPtr<WorkerUnregisterCallback> cb =
- new WorkerUnregisterCallback(Move(mWorkerRef), Move(promise));
+ new WorkerUnregisterCallback(std::move(mWorkerRef), std::move(promise));
nsresult rv = swm->Unregister(principal,
cb,
NS_ConvertUTF8toUTF16(mDescriptor.Scope()));
if (NS_WARN_IF(NS_FAILED(rv))) {
mPromise->Reject(rv, __func__);
return NS_OK;
}
--- a/dom/serviceworkers/ServiceWorkerRegistrationInfo.cpp
+++ b/dom/serviceworkers/ServiceWorkerRegistrationInfo.cpp
@@ -416,17 +416,17 @@ ServiceWorkerRegistrationInfo::UpdateReg
{
MOZ_ASSERT(NS_IsMainThread());
mDescriptor.SetWorkers(mInstallingWorker, mWaitingWorker, mActiveWorker);
RefPtr<ServiceWorkerRegistrationInfo> self(this);
nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction(
"ServiceWorkerRegistrationInfo::UpdateRegistrationState",
- [self = Move(self)] {
+ [self = std::move(self)] {
RefPtr<ServiceWorkerManager> swm = ServiceWorkerManager::GetInstance();
if (swm) {
swm->UpdateRegistrationListeners(self);
}
});
MOZ_ALWAYS_SUCCEEDS(SystemGroup::Dispatch(TaskCategory::Other, r.forget()));
}
--- a/dom/serviceworkers/ServiceWorkerScriptCache.cpp
+++ b/dom/serviceworkers/ServiceWorkerScriptCache.cpp
@@ -151,17 +151,17 @@ public:
{
RefPtr<InternalHeaders> internalHeaders = mInternalHeaders;
return internalHeaders.forget();
}
UniquePtr<PrincipalInfo>
TakePrincipalInfo()
{
- return Move(mPrincipalInfo);
+ return std::move(mPrincipalInfo);
}
bool
Succeeded() const
{
return NS_SUCCEEDED(mNetworkResult);
}
@@ -632,17 +632,17 @@ private:
RefPtr<InternalResponse> ir =
new InternalResponse(200, NS_LITERAL_CSTRING("OK"));
ir->SetBody(body, aCN->Buffer().Length());
ir->SetURLList(aCN->URLList());
ir->InitChannelInfo(aCN->GetChannelInfo());
UniquePtr<PrincipalInfo> principalInfo = aCN->TakePrincipalInfo();
if (principalInfo) {
- ir->SetPrincipalInfo(Move(principalInfo));
+ ir->SetPrincipalInfo(std::move(principalInfo));
}
RefPtr<InternalHeaders> internalHeaders = aCN->GetInternalHeaders();
ir->Headers()->Fill(*(internalHeaders.get()), IgnoreErrors());
RefPtr<Response> response =
new Response(aCache->GetGlobalObject(), ir, nullptr);
@@ -940,17 +940,17 @@ CompareNetwork::SetPrincipalInfo(nsIChan
UniquePtr<PrincipalInfo> principalInfo = MakeUnique<PrincipalInfo>();
rv = PrincipalToPrincipalInfo(channelPrincipal, principalInfo.get());
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
- mPrincipalInfo = Move(principalInfo);
+ mPrincipalInfo = std::move(principalInfo);
return NS_OK;
}
NS_IMETHODIMP
CompareNetwork::OnStopRequest(nsIRequest* aRequest, nsISupports* aContext,
nsresult aStatusCode)
{
// Nothing to do here!
--- a/dom/smil/nsSMILAnimationFunction.cpp
+++ b/dom/smil/nsSMILAnimationFunction.cpp
@@ -264,17 +264,17 @@ nsSMILAnimationFunction::ComposeResult(c
return;
if (NS_FAILED(AccumulateResult(values, result)))
return;
}
// If additive animation isn't required or isn't supported, set the value.
if (!isAdditive || NS_FAILED(aResult.SandwichAdd(result))) {
- aResult = Move(result);
+ aResult = std::move(result);
}
}
int8_t
nsSMILAnimationFunction::CompareTo(const nsSMILAnimationFunction* aOther) const
{
NS_ENSURE_TRUE(aOther, 0);
--- a/dom/smil/nsSMILCSSValueType.cpp
+++ b/dom/smil/nsSMILCSSValueType.cpp
@@ -422,17 +422,17 @@ InterpolateForServo(const ValueWrapper*
Servo_AnimationValues_Interpolate(*startValue,
*endValue,
aUnitDistance).Consume();
if (!result) {
return NS_ERROR_FAILURE;
}
results.AppendElement(result);
}
- aResult.mU.mPtr = new ValueWrapper(aEndWrapper.mPropID, Move(results));
+ aResult.mU.mPtr = new ValueWrapper(aEndWrapper.mPropID, std::move(results));
return NS_OK;
}
nsresult
nsSMILCSSValueType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
@@ -540,17 +540,17 @@ nsSMILCSSValueType::ValueFromString(nsCS
if (aIsContextSensitive) {
// FIXME: Bug 1358955 - detect context-sensitive values and set this value
// appropriately.
*aIsContextSensitive = false;
}
if (!parsedValues.IsEmpty()) {
sSingleton.Init(aValue);
- aValue.mU.mPtr = new ValueWrapper(aPropID, Move(parsedValues));
+ aValue.mU.mPtr = new ValueWrapper(aPropID, std::move(parsedValues));
}
}
// static
nsSMILValue
nsSMILCSSValueType::ValueFromAnimationValue(nsCSSPropertyID aPropID,
Element* aTargetElement,
const AnimationValue& aValue)
@@ -641,13 +641,13 @@ nsSMILCSSValueType::FinalizeValue(nsSMIL
zeroValues.SetCapacity(valueToMatchWrapper->mServoValues.Length());
for (auto& valueToMatch : valueToMatchWrapper->mServoValues) {
RefPtr<RawServoAnimationValue> zeroValue =
Servo_AnimationValues_GetZeroValue(valueToMatch).Consume();
if (!zeroValue) {
return;
}
- zeroValues.AppendElement(Move(zeroValue));
+ zeroValues.AppendElement(std::move(zeroValue));
}
aValue.mU.mPtr = new ValueWrapper(valueToMatchWrapper->mPropID,
- Move(zeroValues));
+ std::move(zeroValues));
}
--- a/dom/smil/nsSMILCompositor.h
+++ b/dom/smil/nsSMILCompositor.h
@@ -30,18 +30,18 @@ public:
typedef const KeyType& KeyTypeRef;
typedef const KeyType* KeyTypePointer;
explicit nsSMILCompositor(KeyTypePointer aKey)
: mKey(*aKey),
mForceCompositing(false)
{ }
nsSMILCompositor(nsSMILCompositor&& toMove)
- : mKey(mozilla::Move(toMove.mKey)),
- mAnimationFunctions(mozilla::Move(toMove.mAnimationFunctions)),
+ : mKey(std::move(toMove.mKey)),
+ mAnimationFunctions(std::move(toMove.mAnimationFunctions)),
mForceCompositing(false)
{ }
~nsSMILCompositor() { }
// PLDHashEntryHdr methods
KeyTypeRef GetKey() const { return mKey; }
bool KeyEquals(KeyTypePointer aKey) const;
static KeyTypePointer KeyToPointer(KeyTypeRef aKey) { return &aKey; }
@@ -64,17 +64,17 @@ public:
void Traverse(nsCycleCollectionTraversalCallback* aCallback);
// Toggles a bit that will force us to composite (bypassing early-return
// optimizations) when we hit ComposeAttribute.
void ToggleForceCompositing() { mForceCompositing = true; }
// Transfers |aOther|'s mCachedBaseValue to |this|
void StealCachedBaseValue(nsSMILCompositor* aOther) {
- mCachedBaseValue = mozilla::Move(aOther->mCachedBaseValue);
+ mCachedBaseValue = std::move(aOther->mCachedBaseValue);
}
private:
// Create a nsISMILAttr for my target, on the heap.
//
// @param aBaseComputedStyle An optional ComputedStyle which, if set, will be
// used when fetching the base style.
mozilla::UniquePtr<nsISMILAttr>
--- a/dom/smil/nsSMILTimedElement.cpp
+++ b/dom/smil/nsSMILTimedElement.cpp
@@ -678,17 +678,17 @@ nsSMILTimedElement::DoSampleAt(nsSMILTim
if (mClient) {
mClient->Inactivate(mFillMode == FILL_FREEZE);
}
mCurrentInterval->FixEnd();
if (mSeekState == SEEK_NOT_SEEKING) {
FireTimeEventAsync(eSMILEndEvent, 0);
}
mCurrentRepeatIteration = 0;
- mOldIntervals.AppendElement(Move(mCurrentInterval));
+ mOldIntervals.AppendElement(std::move(mCurrentInterval));
SampleFillValue();
if (mElementState == STATE_WAITING) {
mCurrentInterval = MakeUnique<nsSMILInterval>(newInterval);
}
// We are now in a consistent state to dispatch notifications
if (didApplyEarlyEnd) {
NotifyChangedInterval(
mOldIntervals[mOldIntervals.Length() - 1].get(), false, true);
@@ -1320,17 +1320,17 @@ nsSMILTimedElement::SetBeginOrEndSpec(co
return NS_ERROR_FAILURE;
}
bool hadFailure = false;
while (tokenizer.hasMoreTokens()) {
auto spec = MakeUnique<nsSMILTimeValueSpec>(*this, aIsBegin);
nsresult rv = spec->SetSpec(tokenizer.nextToken(), aContextNode);
if (NS_SUCCEEDED(rv)) {
- timeSpecsList.AppendElement(Move(spec));
+ timeSpecsList.AppendElement(std::move(spec));
} else {
hadFailure = true;
}
}
// The return value from this function is only used to determine if we should
// print a console message or not, so we return failure if we had one or more
// failures but we don't need to differentiate between different types of
@@ -1606,17 +1606,17 @@ nsSMILTimedElement::FilterIntervals()
for (uint32_t i = 0; i < mOldIntervals.Length(); ++i)
{
nsSMILInterval* interval = mOldIntervals[i].get();
if (i != 0 && /*skip first interval*/
i + 1 < mOldIntervals.Length() && /*skip previous interval*/
(i < threshold || !interval->IsDependencyChainLink())) {
interval->Unlink(true /*filtered, not deleted*/);
} else {
- filteredList.AppendElement(Move(mOldIntervals[i]));
+ filteredList.AppendElement(std::move(mOldIntervals[i]));
}
}
mOldIntervals.Clear();
mOldIntervals.SwapElements(filteredList);
}
namespace
{
--- a/dom/smil/nsSMILTimedElement.h
+++ b/dom/smil/nsSMILTimedElement.h
@@ -553,17 +553,17 @@ protected:
// Reset the current interval by first passing ownership to a temporary
// variable so that if Unlink() results in us receiving a callback,
// mCurrentInterval will be nullptr and we will be in a consistent state.
void ResetCurrentInterval()
{
if (mCurrentInterval) {
// Transfer ownership to temp var. (This sets mCurrentInterval to null.)
- auto interval = mozilla::Move(mCurrentInterval);
+ auto interval = std::move(mCurrentInterval);
interval->Unlink();
}
}
//
// Members
//
mozilla::dom::SVGAnimationElement* mAnimationElement; // [weak] won't outlive
--- a/dom/svg/SVGAnimatedLengthList.cpp
+++ b/dom/svg/SVGAnimatedLengthList.cpp
@@ -139,17 +139,17 @@ SVGAnimatedLengthList::
nsSMILValue& aValue,
bool& aPreventCachingOfSandwich) const
{
nsSMILValue val(&SVGLengthListSMILType::sSingleton);
SVGLengthListAndInfo *llai = static_cast<SVGLengthListAndInfo*>(val.mU.mPtr);
nsresult rv = llai->SetValueFromString(aStr);
if (NS_SUCCEEDED(rv)) {
llai->SetInfo(mElement, mAxis, mCanZeroPadList);
- aValue = Move(val);
+ aValue = std::move(val);
// If any of the lengths in the list depend on their context, then we must
// prevent caching of the entire animation sandwich. This is because the
// units of a length at a given index can change from sandwich layer to
// layer, and indeed even be different within a single sandwich layer. If
// any length in the result of an animation sandwich is the result of the
// addition of lengths where one or more of those lengths is context
// dependent, then naturally the resultant length is also context
@@ -182,17 +182,17 @@ SVGAnimatedLengthList::SMILAnimatedLengt
// from ALL return points. This function must only return THIS variable:
nsSMILValue val;
nsSMILValue tmp(&SVGLengthListSMILType::sSingleton);
SVGLengthListAndInfo *llai = static_cast<SVGLengthListAndInfo*>(tmp.mU.mPtr);
nsresult rv = llai->CopyFrom(mVal->mBaseVal);
if (NS_SUCCEEDED(rv)) {
llai->SetInfo(mElement, mAxis, mCanZeroPadList);
- val = Move(tmp);
+ val = std::move(tmp);
}
return val;
}
nsresult
SVGAnimatedLengthList::SMILAnimatedLengthList::SetAnimValue(const nsSMILValue& aValue)
{
NS_ASSERTION(aValue.mType == &SVGLengthListSMILType::sSingleton,
--- a/dom/svg/SVGAnimatedNumberList.cpp
+++ b/dom/svg/SVGAnimatedNumberList.cpp
@@ -135,17 +135,17 @@ SVGAnimatedNumberList::
nsSMILValue& aValue,
bool& aPreventCachingOfSandwich) const
{
nsSMILValue val(&SVGNumberListSMILType::sSingleton);
SVGNumberListAndInfo *nlai = static_cast<SVGNumberListAndInfo*>(val.mU.mPtr);
nsresult rv = nlai->SetValueFromString(aStr);
if (NS_SUCCEEDED(rv)) {
nlai->SetInfo(mElement);
- aValue = Move(val);
+ aValue = std::move(val);
}
aPreventCachingOfSandwich = false;
return rv;
}
nsSMILValue
SVGAnimatedNumberList::SMILAnimatedNumberList::GetBaseValue() const
{
--- a/dom/svg/SVGAnimatedPathSegList.cpp
+++ b/dom/svg/SVGAnimatedPathSegList.cpp
@@ -163,17 +163,17 @@ SVGAnimatedPathSegList::
nsSMILValue& aValue,
bool& aPreventCachingOfSandwich) const
{
nsSMILValue val(SVGPathSegListSMILType::Singleton());
SVGPathDataAndInfo *list = static_cast<SVGPathDataAndInfo*>(val.mU.mPtr);
nsresult rv = list->SetValueFromString(aStr);
if (NS_SUCCEEDED(rv)) {
list->SetElement(mElement);
- aValue = Move(val);
+ aValue = std::move(val);
}
aPreventCachingOfSandwich = false;
return rv;
}
nsSMILValue
SVGAnimatedPathSegList::SMILAnimatedPathSegList::GetBaseValue() const
{
@@ -182,17 +182,17 @@ SVGAnimatedPathSegList::SMILAnimatedPath
// from ALL return points. This function must only return THIS variable:
nsSMILValue val;
nsSMILValue tmp(SVGPathSegListSMILType::Singleton());
SVGPathDataAndInfo *list = static_cast<SVGPathDataAndInfo*>(tmp.mU.mPtr);
nsresult rv = list->CopyFrom(mVal->mBaseVal);
if (NS_SUCCEEDED(rv)) {
list->SetElement(mElement);
- val = Move(tmp);
+ val = std::move(tmp);
}
return val;
}
nsresult
SVGAnimatedPathSegList::SMILAnimatedPathSegList::SetAnimValue(const nsSMILValue& aValue)
{
NS_ASSERTION(aValue.mType == SVGPathSegListSMILType::Singleton(),
--- a/dom/svg/SVGAnimatedPointList.cpp
+++ b/dom/svg/SVGAnimatedPointList.cpp
@@ -160,17 +160,17 @@ SVGAnimatedPointList::
nsSMILValue& aValue,
bool& aPreventCachingOfSandwich) const
{
nsSMILValue val(&SVGPointListSMILType::sSingleton);
SVGPointListAndInfo *list = static_cast<SVGPointListAndInfo*>(val.mU.mPtr);
nsresult rv = list->SetValueFromString(aStr);
if (NS_SUCCEEDED(rv)) {
list->SetInfo(mElement);
- aValue = Move(val);
+ aValue = std::move(val);
}
aPreventCachingOfSandwich = false;
return rv;
}
nsSMILValue
SVGAnimatedPointList::SMILAnimatedPointList::GetBaseValue() const
{
--- a/dom/svg/SVGElementFactory.cpp
+++ b/dom/svg/SVGElementFactory.cpp
@@ -26,17 +26,17 @@ StaticAutoPtr<TagAtomTable> sTagAtomTabl
nsIContent** aResult, \
already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo); \
\
nsresult NS_NewSVG##_classname##Element( \
nsIContent** aResult, \
already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo, \
FromParser aFromParser) \
{ \
- return NS_NewSVG##_classname##Element(aResult, mozilla::Move(aNodeInfo)); \
+ return NS_NewSVG##_classname##Element(aResult, std::move(aNodeInfo)); \
}
#define SVG_FROM_PARSER_TAG(_tag, _classname)
#include "SVGTagList.h"
#undef SVG_TAG
#undef SVG_FROM_PARSER_TAG
--- a/dom/svg/nsSVGAngle.cpp
+++ b/dom/svg/nsSVGAngle.cpp
@@ -376,17 +376,17 @@ nsSVGAngle::SMILOrient::ValueFromString(
uint16_t unitType;
if (!GetValueFromString(aStr, value, &unitType)) {
return NS_ERROR_DOM_SYNTAX_ERR;
}
val.mU.mOrient.mAngle = value;
val.mU.mOrient.mUnit = unitType;
val.mU.mOrient.mOrientType = SVG_MARKER_ORIENT_ANGLE;
}
- aValue = Move(val);
+ aValue = std::move(val);
aPreventCachingOfSandwich = false;
return NS_OK;
}
nsSMILValue
nsSVGAngle::SMILOrient::GetBaseValue() const
{
--- a/dom/svg/nsSVGAnimatedTransformList.cpp
+++ b/dom/svg/nsSVGAnimatedTransformList.cpp
@@ -256,17 +256,17 @@ nsSVGAnimatedTransformList::SMILAnimated
nsSMILValue val(SVGTransformListSMILType::Singleton());
SVGTransformSMILData transform(transformType, params);
if (NS_FAILED(SVGTransformListSMILType::AppendTransform(transform, val))) {
return; // OOM
}
// Success! Populate our outparam with parsed value.
- aResult = Move(val);
+ aResult = std::move(val);
}
int32_t
nsSVGAnimatedTransformList::SMILAnimatedTransformList::ParseParameterList(
const nsAString& aSpec,
float* aVars,
int32_t aNVars)
{
--- a/dom/svg/nsSVGClass.cpp
+++ b/dom/svg/nsSVGClass.cpp
@@ -127,17 +127,17 @@ nsresult
nsSVGClass::SMILString::ValueFromString(const nsAString& aStr,
const dom::SVGAnimationElement* /*aSrcElement*/,
nsSMILValue& aValue,
bool& aPreventCachingOfSandwich) const
{
nsSMILValue val(SMILStringType::Singleton());
*static_cast<nsAString*>(val.mU.mPtr) = aStr;
- aValue = Move(val);
+ aValue = std::move(val);
aPreventCachingOfSandwich = false;
return NS_OK;
}
nsSMILValue
nsSVGClass::SMILString::GetBaseValue() const
{
nsSMILValue val(SMILStringType::Singleton());
--- a/dom/svg/nsSVGString.cpp
+++ b/dom/svg/nsSVGString.cpp
@@ -107,17 +107,17 @@ nsresult
nsSVGString::SMILString::ValueFromString(const nsAString& aStr,
const dom::SVGAnimationElement* /*aSrcElement*/,
nsSMILValue& aValue,
bool& aPreventCachingOfSandwich) const
{
nsSMILValue val(SMILStringType::Singleton());
*static_cast<nsAString*>(val.mU.mPtr) = aStr;
- aValue = Move(val);
+ aValue = std::move(val);
aPreventCachingOfSandwich = false;
return NS_OK;
}
nsSMILValue
nsSVGString::SMILString::GetBaseValue() const
{
nsSMILValue val(SMILStringType::Singleton());
--- a/dom/svg/nsSVGViewBox.cpp
+++ b/dom/svg/nsSVGViewBox.cpp
@@ -317,17 +317,17 @@ nsSVGViewBox::SMILViewBox
{
nsSVGViewBoxRect viewBox;
nsresult res = nsSVGViewBoxRect::FromString(aStr, &viewBox);
if (NS_FAILED(res)) {
return res;
}
nsSMILValue val(&SVGViewBoxSMILType::sSingleton);
*static_cast<nsSVGViewBoxRect*>(val.mU.mPtr) = viewBox;
- aValue = Move(val);
+ aValue = std::move(val);
aPreventCachingOfSandwich = false;
return NS_OK;
}
nsSMILValue
nsSVGViewBox::SMILViewBox::GetBaseValue() const
{
--- a/dom/system/OSFileConstants.cpp
+++ b/dom/system/OSFileConstants.cpp
@@ -257,17 +257,17 @@ OSFileConstantsService::InitOSFileConsta
GetPathToSpecialDir(NS_OS_TEMP_DIR, paths->tmpDir);
GetPathToSpecialDir(NS_OS_HOME_DIR, paths->homeDir);
GetPathToSpecialDir(XRE_USER_APP_DATA_DIR, paths->userApplicationDataDir);
#if defined(XP_MACOSX)
GetPathToSpecialDir(NS_MAC_USER_LIB_DIR, paths->macUserLibDir);
#endif // defined(XP_MACOSX)
- mPaths = Move(paths);
+ mPaths = std::move(paths);
// Get the umask from the system-info service.
// The property will always be present, but it will be zero on
// non-Unix systems.
// nsSystemInfo::gUserUmask is initialized by NS_InitXPCOM2 so we don't need
// to initialize the service.
mUserUmask = nsSystemInfo::gUserUmask;
--- a/dom/u2f/U2F.cpp
+++ b/dom/u2f/U2F.cpp
@@ -272,17 +272,17 @@ U2F::Register(const nsAString& aAppId,
adjustedAppId,
challenge,
clientData,
adjustedTimeoutMillis,
excludeList,
null_t() /* no extra info for U2F */);
MOZ_ASSERT(mTransaction.isNothing());
- mTransaction = Some(U2FTransaction(Move(AsVariant(callback))));
+ mTransaction = Some(U2FTransaction(std::move(AsVariant(callback))));
mChild->SendRequestRegister(mTransaction.ref().mId, info);
}
void
U2F::FinishMakeCredential(const uint64_t& aTransactionId,
const WebAuthnMakeCredentialResult& aResult)
{
MOZ_ASSERT(NS_IsMainThread());
@@ -418,17 +418,17 @@ U2F::Sign(const nsAString& aAppId,
adjustedAppId,
challenge,
clientData,
adjustedTimeoutMillis,
permittedList,
null_t() /* no extra info for U2F */);
MOZ_ASSERT(mTransaction.isNothing());
- mTransaction = Some(U2FTransaction(Move(AsVariant(callback))));
+ mTransaction = Some(U2FTransaction(std::move(AsVariant(callback))));
mChild->SendRequestSign(mTransaction.ref().mId, info);
}
void
U2F::FinishGetAssertion(const uint64_t& aTransactionId,
const WebAuthnGetAssertionResult& aResult)
{
MOZ_ASSERT(NS_IsMainThread());
@@ -511,17 +511,17 @@ U2F::RejectTransaction(const nsresult& a
if (NS_WARN_IF(mTransaction.isNothing())) {
return;
}
StopListeningForVisibilityEvents();
// Clear out mTransaction before calling ExecuteCallback() below to allow
// reentrancy from microtask checkpoints.
- Maybe<U2FTransaction> maybeTransaction(Move(mTransaction));
+ Maybe<U2FTransaction> maybeTransaction(std::move(mTransaction));
MOZ_ASSERT(mTransaction.isNothing() && maybeTransaction.isSome());
U2FTransaction& transaction = maybeTransaction.ref();
ErrorCode code = ConvertNSResultToErrorCode(aError);
if (transaction.HasRegisterCallback()) {
RegisterResponse response;
response.mErrorCode.Construct(static_cast<uint32_t>(code));
--- a/dom/u2f/U2F.h
+++ b/dom/u2f/U2F.h
@@ -34,17 +34,17 @@ struct RegisteredKey;
class U2FTransaction
{
typedef Variant<nsMainThreadPtrHandle<U2FRegisterCallback>,
nsMainThreadPtrHandle<U2FSignCallback>> U2FCallback;
public:
explicit U2FTransaction(const U2FCallback&& aCallback)
- : mCallback(Move(aCallback))
+ : mCallback(std::move(aCallback))
, mId(NextId())
{
MOZ_ASSERT(mId > 0);
}
bool HasRegisterCallback() {
return mCallback.is<nsMainThreadPtrHandle<U2FRegisterCallback>>();
}
--- a/dom/url/URL.cpp
+++ b/dom/url/URL.cpp
@@ -362,17 +362,17 @@ URL::UpdateURLSearchParams()
}
mSearchParams->ParseInput(search);
}
void
URL::SetURI(already_AddRefed<nsIURI> aURI)
{
- mURI = Move(aURI);
+ mURI = std::move(aURI);
MOZ_ASSERT(mURI);
}
nsIURI*
URL::GetURI() const
{
MOZ_ASSERT(mURI);
return mURI;
--- a/dom/url/URLSearchParams.cpp
+++ b/dom/url/URLSearchParams.cpp
@@ -622,13 +622,13 @@ URLSearchParams::GetSendInfo(nsIInputStr
{
aContentTypeWithCharset.AssignLiteral("application/x-www-form-urlencoded;charset=UTF-8");
aCharset.AssignLiteral("UTF-8");
nsAutoString serialized;
Serialize(serialized);
NS_ConvertUTF16toUTF8 converted(serialized);
*aContentLength = converted.Length();
- return NS_NewCStringInputStream(aBody, Move(converted));
+ return NS_NewCStringInputStream(aBody, std::move(converted));
}
} // namespace dom
} // namespace mozilla
--- a/dom/url/URLWorker.cpp
+++ b/dom/url/URLWorker.cpp
@@ -220,17 +220,17 @@ public:
nsCOMPtr<nsIURI> uri;
nsresult rv = NS_NewURI(getter_AddRefs(uri), mURL, nullptr, baseUri,
nsContentUtils::GetIOService());
if (NS_WARN_IF(NS_FAILED(rv))) {
return true;
}
- mRetval = Move(uri);
+ mRetval = std::move(uri);
return true;
}
nsIURI*
GetURI(ErrorResult& aRv) const
{
MOZ_ASSERT(mWorkerPrivate);
mWorkerPrivate->AssertIsOnWorkerThread();
@@ -313,17 +313,17 @@ public:
}
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), href);
if (NS_WARN_IF(NS_FAILED(rv))) {
return true;
}
- mRetval = Move(uri);
+ mRetval = std::move(uri);
return true;
}
void
Dispatch(ErrorResult& aRv)
{
WorkerMainThreadRunnable::Dispatch(Terminating, aRv);
}
--- a/dom/webauthn/U2FHIDTokenManager.cpp
+++ b/dom/webauthn/U2FHIDTokenManager.cpp
@@ -23,17 +23,17 @@ u2f_register_callback(uint64_t aTransact
StaticMutexAutoLock lock(gInstanceMutex);
if (!gInstance || NS_WARN_IF(!gPBackgroundThread)) {
return;
}
nsCOMPtr<nsIRunnable> r(NewRunnableMethod<UniquePtr<U2FResult>&&>(
"U2FHIDTokenManager::HandleRegisterResult", gInstance,
- &U2FHIDTokenManager::HandleRegisterResult, Move(rv)));
+ &U2FHIDTokenManager::HandleRegisterResult, std::move(rv)));
MOZ_ALWAYS_SUCCEEDS(gPBackgroundThread->Dispatch(r.forget(),
NS_DISPATCH_NORMAL));
}
static void
u2f_sign_callback(uint64_t aTransactionId, rust_u2f_result* aResult)
{
@@ -41,17 +41,17 @@ u2f_sign_callback(uint64_t aTransactionI
StaticMutexAutoLock lock(gInstanceMutex);
if (!gInstance || NS_WARN_IF(!gPBackgroundThread)) {
return;
}
nsCOMPtr<nsIRunnable> r(NewRunnableMethod<UniquePtr<U2FResult>&&>(
"U2FHIDTokenManager::HandleSignResult", gInstance,
- &U2FHIDTokenManager::HandleSignResult, Move(rv)));
+ &U2FHIDTokenManager::HandleSignResult, std::move(rv)));
MOZ_ALWAYS_SUCCEEDS(gPBackgroundThread->Dispatch(r.forget(),
NS_DISPATCH_NORMAL));
}
U2FHIDTokenManager::U2FHIDTokenManager()
{
StaticMutexAutoLock lock(gInstanceMutex);
@@ -292,17 +292,17 @@ U2FHIDTokenManager::HandleRegisterResult
attObj);
if (NS_FAILED(rv)) {
mRegisterPromise.Reject(NS_ERROR_DOM_UNKNOWN_ERR, __func__);
return;
}
WebAuthnMakeCredentialResult result(mTransaction.ref().mClientDataJSON,
attObj, keyHandle, regData);
- mRegisterPromise.Resolve(Move(result), __func__);
+ mRegisterPromise.Resolve(std::move(result), __func__);
}
void
U2FHIDTokenManager::HandleSignResult(UniquePtr<U2FResult>&& aResult)
{
mozilla::ipc::AssertIsOnBackgroundThread();
if (mTransaction.isNothing() ||
@@ -375,13 +375,13 @@ U2FHIDTokenManager::HandleSignResult(Uni
if (NS_WARN_IF(NS_FAILED(rv))) {
mSignPromise.Reject(NS_ERROR_DOM_UNKNOWN_ERR, __func__);
return;
}
WebAuthnGetAssertionResult result(mTransaction.ref().mClientDataJSON,
keyHandle, signatureBuf, authenticatorData,
extensions, rawSignatureBuf);
- mSignPromise.Resolve(Move(result), __func__);
+ mSignPromise.Resolve(std::move(result), __func__);
}
}
}
--- a/dom/webauthn/U2FSoftTokenManager.cpp
+++ b/dom/webauthn/U2FSoftTokenManager.cpp
@@ -725,17 +725,17 @@ U2FSoftTokenManager::Register(const WebA
attestCertBuf, signatureBuf,
aForceNoneAttestation, attObj);
if (NS_FAILED(rv)) {
return U2FRegisterPromise::CreateAndReject(NS_ERROR_FAILURE, __func__);
}
WebAuthnMakeCredentialResult result(aInfo.ClientDataJSON(), attObj,
keyHandleBuf, registrationBuf);
- return U2FRegisterPromise::CreateAndResolve(Move(result), __func__);
+ return U2FRegisterPromise::CreateAndResolve(std::move(result), __func__);
}
bool
U2FSoftTokenManager::FindRegisteredKeyHandle(const nsTArray<nsTArray<uint8_t>>& aAppIds,
const nsTArray<WebAuthnScopedCredential>& aCredentials,
/*out*/ nsTArray<uint8_t>& aKeyHandle,
/*out*/ nsTArray<uint8_t>& aAppId)
{
@@ -937,17 +937,17 @@ U2FSoftTokenManager::Sign(const WebAuthn
emptyAttestationData, authenticatorData);
if (NS_WARN_IF(NS_FAILED(rv))) {
return U2FSignPromise::CreateAndReject(NS_ERROR_FAILURE, __func__);
}
WebAuthnGetAssertionResult result(aInfo.ClientDataJSON(), keyHandle,
signatureBuf, authenticatorData,
extensions, signatureDataBuf);
- return U2FSignPromise::CreateAndResolve(Move(result), __func__);
+ return U2FSignPromise::CreateAndResolve(std::move(result), __func__);
}
void
U2FSoftTokenManager::Cancel()
{
// This implementation is sync, requests can't be aborted.
}
--- a/dom/webbrowserpersist/WebBrowserPersistSerializeChild.cpp
+++ b/dom/webbrowserpersist/WebBrowserPersistSerializeChild.cpp
@@ -98,17 +98,17 @@ WebBrowserPersistSerializeChild::Write(c
const char* buf = aBuf;
uint32_t count = aCount;
*aWritten = 0;
while (count > 0) {
uint32_t toWrite = std::min(IPC::MAX_MESSAGE_SIZE, count);
nsTArray<uint8_t> arrayBuf;
// It would be nice if this extra copy could be avoided.
arrayBuf.AppendElements(buf, toWrite);
- SendWriteData(Move(arrayBuf));
+ SendWriteData(std::move(arrayBuf));
*aWritten += toWrite;
buf += toWrite;
count -= toWrite;
}
return NS_OK;
}
NS_IMETHODIMP
--- a/dom/webbrowserpersist/nsWebBrowserPersist.cpp
+++ b/dom/webbrowserpersist/nsWebBrowserPersist.cpp
@@ -1794,17 +1794,17 @@ nsWebBrowserPersist::FinishSaveDocumentI
mWalkStack.TruncateLength(mWalkStack.Length() - 1);
// Bounce this off the event loop to avoid stack overflow.
typedef StoreCopyPassByRRef<decltype(toWalk)> WalkStorage;
auto saveMethod = &nsWebBrowserPersist::SaveDocumentDeferred;
nsCOMPtr<nsIRunnable> saveLater = NewRunnableMethod<WalkStorage>(
"nsWebBrowserPersist::FinishSaveDocumentInternal",
this,
saveMethod,
- mozilla::Move(toWalk));
+ std::move(toWalk));
NS_DispatchToCurrentThread(saveLater);
} else {
// Done walking DOMs; on to the serialization phase.
SerializeNextFile();
}
}
void nsWebBrowserPersist::Cleanup()
@@ -2686,17 +2686,17 @@ nsWebBrowserPersist::SaveSubframeContent
// We shouldn't use SaveDocumentInternal for the contents
// of frames that are not documents, e.g. images.
if (DocumentEncoderExists(contentType.get())) {
auto toWalk = mozilla::MakeUnique<WalkData>();
toWalk->mDocument = aFrameContent;
toWalk->mFile = frameURI;
toWalk->mDataPath = frameDataURI;
- mWalkStack.AppendElement(mozilla::Move(toWalk));
+ mWalkStack.AppendElement(std::move(toWalk));
} else {
rv = StoreURI(aURISpec.get());
}
NS_ENSURE_SUCCESS(rv, rv);
// Store the updated uri to the frame
aData->mFile = frameURI;
aData->mSubFrameExt.Truncate(); // we already put this in frameURI
--- a/dom/websocket/WebSocket.cpp
+++ b/dom/websocket/WebSocket.cpp
@@ -2778,17 +2778,17 @@ class WorkerRunnableDispatcher final : p
{
RefPtr<WebSocketImpl> mWebSocketImpl;
public:
WorkerRunnableDispatcher(WebSocketImpl* aImpl, ThreadSafeWorkerRef* aWorkerRef,
already_AddRefed<nsIRunnable> aEvent)
: WorkerRunnable(aWorkerRef->Private(), WorkerThreadUnchangedBusyCount)
, mWebSocketImpl(aImpl)
- , mEvent(Move(aEvent))
+ , mEvent(std::move(aEvent))
{
}
bool WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
{
aWorkerPrivate->AssertIsOnWorkerThread();
// No messages when disconnected.
--- a/dom/workers/ChromeWorker.cpp
+++ b/dom/workers/ChromeWorker.cpp
@@ -47,17 +47,17 @@ ChromeWorker::WorkerAvailable(JSContext*
return nsContentUtils::IsSystemCaller(aCx);
}
return GetWorkerPrivateFromContext(aCx)->IsChromeWorker();
}
ChromeWorker::ChromeWorker(nsIGlobalObject* aGlobalObject,
already_AddRefed<WorkerPrivate> aWorkerPrivate)
- : Worker(aGlobalObject, Move(aWorkerPrivate))
+ : Worker(aGlobalObject, std::move(aWorkerPrivate))
{}
ChromeWorker::~ChromeWorker() = default;
JSObject*
ChromeWorker::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
{
JS::Rooted<JSObject*> wrapper(aCx,
--- a/dom/workers/RuntimeService.cpp
+++ b/dom/workers/RuntimeService.cpp
@@ -1417,17 +1417,17 @@ RuntimeService::RegisterWorker(WorkerPri
MOZ_CRASH("We should not instantiate a new SharedWorker!");
}
}
#endif
UniquePtr<SharedWorkerInfo> sharedWorkerInfo(
new SharedWorkerInfo(aWorkerPrivate, sharedWorkerScriptSpec,
aWorkerPrivate->WorkerName()));
- domainInfo->mSharedWorkerInfos.AppendElement(Move(sharedWorkerInfo));
+ domainInfo->mSharedWorkerInfos.AppendElement(std::move(sharedWorkerInfo));
}
}
// From here on out we must call UnregisterWorker if something fails!
if (parent) {
if (!parent->AddChildWorker(aWorkerPrivate)) {
UnregisterWorker(aWorkerPrivate);
return false;
--- a/dom/workers/ScriptLoader.cpp
+++ b/dom/workers/ScriptLoader.cpp
@@ -773,17 +773,17 @@ private:
UniquePtr<PrincipalInfo> principalInfo(new PrincipalInfo());
rv = PrincipalToPrincipalInfo(channelPrincipal, principalInfo.get());
if (NS_WARN_IF(NS_FAILED(rv))) {
channel->Cancel(rv);
return rv;
}
- ir->SetPrincipalInfo(Move(principalInfo));
+ ir->SetPrincipalInfo(std::move(principalInfo));
ir->Headers()->FillResponseHeaders(loadInfo.mChannel);
RefPtr<mozilla::dom::Response> response =
new mozilla::dom::Response(mCacheCreator->Global(), ir, nullptr);
mozilla::dom::RequestOrUSVString request;
MOZ_ASSERT(!loadInfo.mFullURL.IsEmpty());
@@ -1049,17 +1049,17 @@ private:
rv = NS_NewStreamLoader(getter_AddRefs(loader), listener);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
if (IsMainWorkerScript()) {
MOZ_DIAGNOSTIC_ASSERT(loadInfo.mReservedClientInfo.isSome());
rv = AddClientChannelHelper(channel,
- Move(loadInfo.mReservedClientInfo),
+ std::move(loadInfo.mReservedClientInfo),
Maybe<ClientInfo>(),
mWorkerPrivate->HybridEventTarget());
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
}
if (loadInfo.mCacheStatus != ScriptLoadInfo::ToBeCached) {
@@ -1829,17 +1829,17 @@ CacheScriptLoader::ResolvedCallback(JSCo
const UniquePtr<PrincipalInfo>& pInfo = response->GetPrincipalInfo();
if (pInfo) {
mPrincipalInfo = mozilla::MakeUnique<PrincipalInfo>(*pInfo);
}
if (!inputStream) {
mLoadInfo.mCacheStatus = ScriptLoadInfo::Cached;
mRunnable->DataReceivedFromCache(mIndex, (uint8_t*)"", 0, mChannelInfo,
- Move(mPrincipalInfo), mCSPHeaderValue,
+ std::move(mPrincipalInfo), mCSPHeaderValue,
mCSPReportOnlyHeaderValue,
mReferrerPolicyHeaderValue);
return;
}
MOZ_ASSERT(!mPump);
rv = NS_NewInputStreamPump(getter_AddRefs(mPump),
inputStream.forget(),
@@ -1896,17 +1896,17 @@ CacheScriptLoader::OnStreamComplete(nsIS
return NS_OK;
}
MOZ_ASSERT(mLoadInfo.mCacheStatus == ScriptLoadInfo::ReadingFromCache);
mLoadInfo.mCacheStatus = ScriptLoadInfo::Cached;
MOZ_ASSERT(mPrincipalInfo);
mRunnable->DataReceivedFromCache(mIndex, aString, aStringLen, mChannelInfo,
- Move(mPrincipalInfo), mCSPHeaderValue,
+ std::move(mPrincipalInfo), mCSPHeaderValue,
mCSPReportOnlyHeaderValue,
mReferrerPolicyHeaderValue);
return NS_OK;
}
class ChannelGetterRunnable final : public WorkerMainThreadRunnable
{
const nsAString& mScriptURL;
--- a/dom/workers/Worker.cpp
+++ b/dom/workers/Worker.cpp
@@ -35,17 +35,17 @@ Worker::Constructor(const GlobalObject&
RefPtr<Worker> worker = new Worker(globalObject, workerPrivate.forget());
return worker.forget();
}
Worker::Worker(nsIGlobalObject* aGlobalObject,
already_AddRefed<WorkerPrivate> aWorkerPrivate)
: DOMEventTargetHelper(aGlobalObject)
- , mWorkerPrivate(Move(aWorkerPrivate))
+ , mWorkerPrivate(std::move(aWorkerPrivate))
{
MOZ_ASSERT(mWorkerPrivate);
mWorkerPrivate->SetParentEventTargetRef(this);
}
Worker::~Worker()
{
Terminate();
--- a/dom/workers/WorkerPrivate.cpp
+++ b/dom/workers/WorkerPrivate.cpp
@@ -2862,17 +2862,17 @@ WorkerPrivate::Constructor(JSContext* aC
// WorkerThreadPrimaryRunnable::Run for workers just before running worker
// code), so this is never SpiderMonkey's builtin default locale.
JS::UniqueChars defaultLocale = JS_GetDefaultLocale(aCx);
if (NS_WARN_IF(!defaultLocale)) {
aRv.Throw(NS_ERROR_UNEXPECTED);
return nullptr;
}
- worker->mDefaultLocale = Move(defaultLocale);
+ worker->mDefaultLocale = std::move(defaultLocale);
if (!runtimeService->RegisterWorker(worker)) {
aRv.Throw(NS_ERROR_UNEXPECTED);
return nullptr;
}
worker->EnableDebugger();
@@ -3405,17 +3405,17 @@ WorkerPrivate::DispatchToMainThread(nsIR
nsCOMPtr<nsIRunnable> r = aRunnable;
return DispatchToMainThread(r.forget(), aFlags);
}
nsresult
WorkerPrivate::DispatchToMainThread(already_AddRefed<nsIRunnable> aRunnable,
uint32_t aFlags)
{
- return mMainThreadEventTarget->Dispatch(Move(aRunnable), aFlags);
+ return mMainThreadEventTarget->Dispatch(std::move(aRunnable), aFlags);
}
nsISerialEventTarget*
WorkerPrivate::ControlEventTarget()
{
return mWorkerControlEventTarget;
}
@@ -3495,30 +3495,30 @@ WorkerPrivate::EnsurePerformanceStorage(
Maybe<ClientInfo>
WorkerPrivate::GetClientInfo() const
{
AssertIsOnWorkerThread();
Maybe<ClientInfo> clientInfo;
if (!mClientSource) {
MOZ_DIAGNOSTIC_ASSERT(mStatus >= Terminating);
- return Move(clientInfo);
+ return std::move(clientInfo);
}
clientInfo.emplace(mClientSource->Info());
- return Move(clientInfo);
+ return std::move(clientInfo);
}
const ClientState
WorkerPrivate::GetClientState() const
{
AssertIsOnWorkerThread();
MOZ_DIAGNOSTIC_ASSERT(mClientSource);
ClientState state;
mClientSource->SnapshotState(&state);
- return Move(state);
+ return std::move(state);
}
const Maybe<ServiceWorkerDescriptor>
WorkerPrivate::GetController()
{
AssertIsOnWorkerThread();
{
MutexAutoLock lock(mMutex);
@@ -5297,17 +5297,17 @@ WorkerPrivate::GetOrCreateGlobalScope(JS
JS::Rooted<JSObject*> global(aCx);
NS_ENSURE_TRUE(globalScope->WrapGlobalObject(aCx, &global), nullptr);
JSAutoRealm ar(aCx, global);
// RegisterBindings() can spin a nested event loop so we have to set mScope
// before calling it, and we have to make sure to unset mScope if it fails.
- mScope = Move(globalScope);
+ mScope = std::move(globalScope);
if (!RegisterBindings(aCx, global)) {
mScope = nullptr;
return nullptr;
}
JS_FireOnNewGlobalObject(aCx, global);
}
@@ -5328,17 +5328,17 @@ WorkerPrivate::CreateDebuggerGlobalScope
JS::Rooted<JSObject*> global(aCx);
NS_ENSURE_TRUE(globalScope->WrapGlobalObject(aCx, &global), nullptr);
JSAutoRealm ar(aCx, global);
// RegisterDebuggerBindings() can spin a nested event loop so we have to set
// mDebuggerScope before calling it, and we have to make sure to unset
// mDebuggerScope if it fails.
- mDebuggerScope = Move(globalScope);
+ mDebuggerScope = std::move(globalScope);
if (!RegisterDebuggerBindings(aCx, global)) {
mDebuggerScope = nullptr;
return nullptr;
}
JS_FireOnNewGlobalObject(aCx, global);
--- a/dom/workers/WorkerPrivate.h
+++ b/dom/workers/WorkerPrivate.h
@@ -242,17 +242,17 @@ public:
}
JS::UniqueChars
AdoptDefaultLocale()
{
MOZ_ASSERT(mDefaultLocale,
"the default locale must have been successfully set for anyone "
"to be trying to adopt it");
- return Move(mDefaultLocale);
+ return std::move(mDefaultLocale);
}
void
DoRunLoop(JSContext* aCx);
bool
InterruptCallback(JSContext* aCx);
--- a/dom/workers/WorkerRef.cpp
+++ b/dom/workers/WorkerRef.cpp
@@ -19,17 +19,17 @@ namespace {
// This runnable is used to release the StrongWorkerRef on the worker thread
// when a ThreadSafeWorkerRef is released.
class ReleaseRefControlRunnable final : public WorkerControlRunnable
{
public:
ReleaseRefControlRunnable(WorkerPrivate* aWorkerPrivate,
already_AddRefed<StrongWorkerRef> aRef)
: WorkerControlRunnable(aWorkerPrivate, WorkerThreadUnchangedBusyCount)
- , mRef(Move(aRef))
+ , mRef(std::move(aRef))
{
MOZ_ASSERT(mRef);
}
bool
PreDispatch(WorkerPrivate* aWorkerPrivate) override
{
return true;
@@ -131,17 +131,17 @@ WeakWorkerRef::Create(WorkerPrivate* aWo
// This holder doesn't keep the worker alive.
UniquePtr<Holder> holder(new Holder("WeakWorkerRef::Holder", ref,
WorkerHolder::AllowIdleShutdownStart));
if (NS_WARN_IF(!holder->HoldWorker(aWorkerPrivate, Canceling))) {
return nullptr;
}
- ref->mHolder = Move(holder);
+ ref->mHolder = std::move(holder);
ref->mCallback = aCallback;
return ref.forget();
}
WeakWorkerRef::WeakWorkerRef(WorkerPrivate* aWorkerPrivate)
: WorkerRef(aWorkerPrivate)
{}
@@ -185,17 +185,17 @@ StrongWorkerRef::Create(WorkerPrivate* a
// The worker is kept alive by this holder.
UniquePtr<Holder> holder(new Holder(aName, ref,
WorkerHolder::PreventIdleShutdownStart));
if (NS_WARN_IF(!holder->HoldWorker(aWorkerPrivate, Canceling))) {
return nullptr;
}
- ref->mHolder = Move(holder);
+ ref->mHolder = std::move(holder);
ref->mCallback = aCallback;
return ref.forget();
}
StrongWorkerRef::StrongWorkerRef(WorkerPrivate* aWorkerPrivate)
: WorkerRef(aWorkerPrivate)
{}
--- a/dom/workers/WorkerRunnable.cpp
+++ b/dom/workers/WorkerRunnable.cpp
@@ -471,17 +471,17 @@ MainThreadWorkerSyncRunnable::PostDispat
bool aDispatchResult)
{
}
MainThreadStopSyncLoopRunnable::MainThreadStopSyncLoopRunnable(
WorkerPrivate* aWorkerPrivate,
already_AddRefed<nsIEventTarget>&& aSyncLoopTarget,
bool aResult)
-: WorkerSyncRunnable(aWorkerPrivate, Move(aSyncLoopTarget)), mResult(aResult)
+: WorkerSyncRunnable(aWorkerPrivate, std::move(aSyncLoopTarget)), mResult(aResult)
{
AssertIsOnMainThread();
#ifdef DEBUG
mWorkerPrivate->AssertValidSyncLoop(mSyncLoopTarget);
#endif
}
nsresult
@@ -763,17 +763,17 @@ WorkerProxyToMainThreadRunnable::HoldWor
}
};
UniquePtr<WorkerHolder> workerHolder(new SimpleWorkerHolder());
if (NS_WARN_IF(!workerHolder->HoldWorker(mWorkerPrivate, Canceling))) {
return false;
}
- mWorkerHolder = Move(workerHolder);
+ mWorkerHolder = std::move(workerHolder);
return true;
}
void
WorkerProxyToMainThreadRunnable::ReleaseWorker()
{
mWorkerPrivate->AssertIsOnWorkerThread();
MOZ_ASSERT(mWorkerHolder);
--- a/dom/workers/WorkerRunnable.h
+++ b/dom/workers/WorkerRunnable.h
@@ -244,17 +244,17 @@ protected:
nsIEventTarget* aSyncLoopTarget)
: WorkerSyncRunnable(aWorkerPrivate, aSyncLoopTarget)
{
AssertIsOnMainThread();
}
MainThreadWorkerSyncRunnable(WorkerPrivate* aWorkerPrivate,
already_AddRefed<nsIEventTarget>&& aSyncLoopTarget)
- : WorkerSyncRunnable(aWorkerPrivate, Move(aSyncLoopTarget))
+ : WorkerSyncRunnable(aWorkerPrivate, std::move(aSyncLoopTarget))
{
AssertIsOnMainThread();
}
virtual ~MainThreadWorkerSyncRunnable()
{ }
private:
--- a/dom/workers/WorkerScope.cpp
+++ b/dom/workers/WorkerScope.cpp
@@ -516,17 +516,17 @@ WorkerGlobalScope::CreateImageBitmap(JSC
return nullptr;
}
}
nsresult
WorkerGlobalScope::Dispatch(TaskCategory aCategory,
already_AddRefed<nsIRunnable>&& aRunnable)
{
- return EventTargetFor(aCategory)->Dispatch(Move(aRunnable),
+ return EventTargetFor(aCategory)->Dispatch(std::move(aRunnable),
NS_DISPATCH_NORMAL);
}
nsISerialEventTarget*
WorkerGlobalScope::EventTargetFor(TaskCategory aCategory) const
{
return mSerialEventTarget;
}
@@ -543,17 +543,17 @@ WorkerGlobalScope::GetClientInfo() const
return mWorkerPrivate->GetClientInfo();
}
Maybe<ClientState>
WorkerGlobalScope::GetClientState() const
{
Maybe<ClientState> state;
state.emplace(mWorkerPrivate->GetClientState());
- return Move(state);
+ return std::move(state);
}
Maybe<ServiceWorkerDescriptor>
WorkerGlobalScope::GetController() const
{
return mWorkerPrivate->GetController();
}
@@ -1129,17 +1129,17 @@ WorkerDebuggerGlobalScope::Dump(JSContex
scope->Dump(aString);
}
}
nsresult
WorkerDebuggerGlobalScope::Dispatch(TaskCategory aCategory,
already_AddRefed<nsIRunnable>&& aRunnable)
{
- return EventTargetFor(aCategory)->Dispatch(Move(aRunnable),
+ return EventTargetFor(aCategory)->Dispatch(std::move(aRunnable),
NS_DISPATCH_NORMAL);
}
nsISerialEventTarget*
WorkerDebuggerGlobalScope::EventTargetFor(TaskCategory aCategory) const
{
return mSerialEventTarget;
}
--- a/dom/worklet/Worklet.cpp
+++ b/dom/worklet/Worklet.cpp
@@ -29,17 +29,17 @@ namespace dom {
class ExecutionRunnable final : public Runnable
{
public:
ExecutionRunnable(WorkletFetchHandler* aHandler, Worklet::WorkletType aType,
JS::UniqueTwoByteChars aScriptBuffer, size_t aScriptLength,
const WorkletLoadInfo& aWorkletLoadInfo)
: Runnable("Worklet::ExecutionRunnable")
, mHandler(aHandler)
- , mScriptBuffer(Move(aScriptBuffer))
+ , mScriptBuffer(std::move(aScriptBuffer))
, mScriptLength(aScriptLength)
, mWorkletType(aType)
, mResult(NS_ERROR_FAILURE)
{
MOZ_ASSERT(NS_IsMainThread());
}
NS_IMETHOD
@@ -219,17 +219,17 @@ public:
scriptTextBuf, scriptTextLength);
if (NS_WARN_IF(NS_FAILED(rv))) {
RejectPromises(rv);
return NS_OK;
}
// Moving the ownership of the buffer
nsCOMPtr<nsIRunnable> runnable =
- new ExecutionRunnable(this, mWorklet->Type(), Move(scriptTextBuf),
+ new ExecutionRunnable(this, mWorklet->Type(), std::move(scriptTextBuf),
scriptTextLength, mWorklet->LoadInfo());
RefPtr<WorkletThread> thread = mWorklet->GetOrCreateThread();
if (!thread) {
RejectPromises(NS_ERROR_FAILURE);
return NS_OK;
}
--- a/dom/xbl/nsXBLDocumentInfo.cpp
+++ b/dom/xbl/nsXBLDocumentInfo.cpp
@@ -201,17 +201,17 @@ nsXBLDocumentInfo::ReadPrototypeBindings
UniquePtr<char[]> buf;
uint32_t len;
rv = startupCache->GetBuffer(spec.get(), &buf, &len);
// GetBuffer will fail if the binding is not in the cache.
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIObjectInputStream> stream;
- rv = NewObjectInputStreamFromBuffer(Move(buf), len, getter_AddRefs(stream));
+ rv = NewObjectInputStreamFromBuffer(std::move(buf), len, getter_AddRefs(stream));
NS_ENSURE_SUCCESS(rv, rv);
// The file compatibility.ini stores the build id. This is checked in
// nsAppRunner.cpp and will delete the cache if a different build is
// present. However, we check that the version matches here to be safe.
uint32_t version;
rv = stream->Read32(&version);
NS_ENSURE_SUCCESS(rv, rv);
@@ -288,17 +288,17 @@ nsXBLDocumentInfo::WritePrototypeBinding
stream->Close();
NS_ENSURE_SUCCESS(rv, rv);
uint32_t len;
UniquePtr<char[]> buf;
rv = NewBufferFromStorageStream(storageStream, &buf, &len);
NS_ENSURE_SUCCESS(rv, rv);
- return startupCache->PutBuffer(spec.get(), Move(buf), len);
+ return startupCache->PutBuffer(spec.get(), std::move(buf), len);
}
void
nsXBLDocumentInfo::SetFirstPrototypeBinding(nsXBLPrototypeBinding* aBinding)
{
mFirstBinding = aBinding;
}
--- a/dom/xbl/nsXBLWindowKeyHandler.cpp
+++ b/dom/xbl/nsXBLWindowKeyHandler.cpp
@@ -453,17 +453,17 @@ nsXBLWindowKeyHandler::CollectKeyboardSh
handler;
handler = handler->GetNextHandler()) {
KeyboardShortcut shortcut;
if (handler->TryConvertToKeyboardShortcut(&shortcut)) {
shortcuts.AppendElement(shortcut);
}
}
- return KeyboardMap(mozilla::Move(shortcuts));
+ return KeyboardMap(std::move(shortcuts));
}
nsAtom*
nsXBLWindowKeyHandler::ConvertEventToDOMEventType(
const WidgetKeyboardEvent& aWidgetKeyboardEvent) const
{
if (aWidgetKeyboardEvent.IsKeyDownOrKeyDownOnPlugin()) {
return nsGkAtoms::keydown;
--- a/dom/xhr/XMLHttpRequestMainThread.cpp
+++ b/dom/xhr/XMLHttpRequestMainThread.cpp
@@ -2436,17 +2436,17 @@ XMLHttpRequestMainThread::MaybeLowerChan
}
nsresult
XMLHttpRequestMainThread::InitiateFetch(already_AddRefed<nsIInputStream> aUploadStream,
int64_t aUploadLength,
nsACString& aUploadContentType)
{
nsresult rv;
- nsCOMPtr<nsIInputStream> uploadStream = Move(aUploadStream);
+ nsCOMPtr<nsIInputStream> uploadStream = std::move(aUploadStream);
// nsIRequest::LOAD_BACKGROUND prevents throbber from becoming active, which
// in turn keeps STOP button from becoming active. If the consumer passed in
// a progress event handler we must load with nsIRequest::LOAD_NORMAL or
// necko won't generate any progress notifications.
if (HasListenersFor(nsGkAtoms::onprogress) ||
(mUpload && mUpload->HasListenersFor(nsGkAtoms::onprogress))) {
nsLoadFlags loadFlags;
@@ -3048,20 +3048,20 @@ XMLHttpRequestMainThread::SetTimerEventT
nsresult
XMLHttpRequestMainThread::DispatchToMainThread(already_AddRefed<nsIRunnable> aRunnable)
{
if (nsCOMPtr<nsIGlobalObject> global = GetOwnerGlobal()) {
nsCOMPtr<nsIEventTarget> target = global->EventTargetFor(TaskCategory::Other);
MOZ_ASSERT(target);
- return target->Dispatch(Move(aRunnable), NS_DISPATCH_NORMAL);
- }
-
- return NS_DispatchToMainThread(Move(aRunnable));
+ return target->Dispatch(std::move(aRunnable), NS_DISPATCH_NORMAL);
+ }
+
+ return NS_DispatchToMainThread(std::move(aRunnable));
}
void
XMLHttpRequestMainThread::StartTimeoutTimer()
{
MOZ_ASSERT(mRequestSentTime,
"StartTimeoutTimer mustn't be called before the request was sent!");
if (mState == XMLHttpRequestBinding::DONE) {
--- a/dom/xml/ProcessingInstruction.cpp
+++ b/dom/xml/ProcessingInstruction.cpp
@@ -43,17 +43,17 @@ NS_NewXMLProcessingInstruction(nsNodeInf
return instance.forget();
}
namespace mozilla {
namespace dom {
ProcessingInstruction::ProcessingInstruction(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
const nsAString& aData)
- : CharacterData(Move(aNodeInfo))
+ : CharacterData(std::move(aNodeInfo))
{
MOZ_ASSERT(mNodeInfo->NodeType() == nsINode::PROCESSING_INSTRUCTION_NODE,
"Bad NodeType in aNodeInfo");
SetTextInternal(0, mText.GetLength(),
aData.BeginReading(), aData.Length(),
false); // Don't notify (bug 420429).
}
--- a/dom/xml/XMLStylesheetProcessingInstruction.h
+++ b/dom/xml/XMLStylesheetProcessingInstruction.h
@@ -17,17 +17,17 @@ namespace mozilla {
namespace dom {
class XMLStylesheetProcessingInstruction final
: public ProcessingInstruction
{
public:
XMLStylesheetProcessingInstruction(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
const nsAString& aData)
- : ProcessingInstruction(Move(aNodeInfo), aData)
+ : ProcessingInstruction(std::move(aNodeInfo), aData)
{
}
XMLStylesheetProcessingInstruction(nsNodeInfoManager* aNodeInfoManager,
const nsAString& aData)
: ProcessingInstruction(aNodeInfoManager->GetNodeInfo(
nsGkAtoms::processingInstructionTagName,
nullptr, kNameSpaceID_None,
--- a/dom/xslt/xpath/XPathEvaluator.cpp
+++ b/dom/xslt/xpath/XPathEvaluator.cpp
@@ -111,17 +111,17 @@ XPathEvaluator::CreateExpression(const n
if (!aRv.ErrorCodeIs(NS_ERROR_DOM_NAMESPACE_ERR)) {
aRv.SuppressException();
aRv.Throw(NS_ERROR_DOM_INVALID_EXPRESSION_ERR);
}
return nullptr;
}
- return new XPathExpression(Move(expression), mRecycler, aDocument);
+ return new XPathExpression(std::move(expression), mRecycler, aDocument);
}
bool
XPathEvaluator::WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto,
JS::MutableHandle<JSObject*> aReflector)
{
return dom::XPathEvaluatorBinding::Wrap(aCx, this, aGivenProto, aReflector);
--- a/dom/xslt/xpath/XPathExpression.cpp
+++ b/dom/xslt/xpath/XPathExpression.cpp
@@ -49,17 +49,17 @@ private:
uint32_t mContextSize;
nsresult mLastError;
RefPtr<txResultRecycler> mRecycler;
};
XPathExpression::XPathExpression(nsAutoPtr<Expr>&& aExpression,
txResultRecycler* aRecycler,
nsIDocument *aDocument)
- : mExpression(Move(aExpression)),
+ : mExpression(std::move(aExpression)),
mRecycler(aRecycler),
mDocument(do_GetWeakReference(aDocument)),
mCheckDocument(aDocument != nullptr)
{
}
XPathExpression::~XPathExpression()
{
--- a/dom/xslt/xpath/txExprParser.cpp
+++ b/dom/xslt/xpath/txExprParser.cpp
@@ -111,17 +111,17 @@ txExprParser::createAVT(const nsAString&
if (inExpr) {
aContext->SetErrorOffset(start - avtStart);
return NS_ERROR_XPATH_UNBALANCED_CURLY_BRACE;
}
}
// Add expression, create a concat() call if necessary
if (!expr) {
- expr = Move(newExpr);
+ expr = std::move(newExpr);
}
else {
if (!concat) {
concat = new txCoreFunctionCall(txCoreFunctionCall::CONCAT);
rv = concat->addParam(expr.forget());
expr = concat;
NS_ENSURE_SUCCESS(rv, rv);
}
@@ -307,17 +307,17 @@ txExprParser::createExpr(txExprLexer& le
short tokPrecedence = precedence(lexer.peek());
if (tokPrecedence != 0) {
Token* tok = lexer.nextToken();
while (!exprs.isEmpty() && tokPrecedence
<= precedence(static_cast<Token*>(ops.peek()))) {
// can't use expr as argument due to order of evaluation
nsAutoPtr<Expr> left(static_cast<Expr*>(exprs.pop()));
- nsAutoPtr<Expr> right(Move(expr));
+ nsAutoPtr<Expr> right(std::move(expr));
rv = createBinaryExpr(left, right,
static_cast<Token*>(ops.pop()),
getter_Transfers(expr));
if (NS_FAILED(rv)) {
done = true;
break;
}
}
@@ -326,17 +326,17 @@ txExprParser::createExpr(txExprLexer& le
}
else {
done = true;
}
}
while (NS_SUCCEEDED(rv) && !exprs.isEmpty()) {
nsAutoPtr<Expr> left(static_cast<Expr*>(exprs.pop()));
- nsAutoPtr<Expr> right(Move(expr));
+ nsAutoPtr<Expr> right(std::move(expr));
rv = createBinaryExpr(left, right, static_cast<Token*>(ops.pop()),
getter_Transfers(expr));
}
// clean up on error
while (!exprs.isEmpty()) {
delete static_cast<Expr*>(exprs.pop());
}
NS_ENSURE_SUCCESS(rv, rv);
--- a/dom/xslt/xslt/txInstructions.cpp
+++ b/dom/xslt/xslt/txInstructions.cpp
@@ -96,17 +96,17 @@ txApplyTemplates::execute(txExecutionSta
aEs.pushTemplateRule(frame, mMode, aEs.mTemplateParams);
return aEs.runTemplate(templ);
}
txAttribute::txAttribute(nsAutoPtr<Expr>&& aName, nsAutoPtr<Expr>&& aNamespace,
txNamespaceMap* aMappings)
- : mName(Move(aName)), mNamespace(Move(aNamespace)), mMappings(aMappings)
+ : mName(std::move(aName)), mNamespace(std::move(aNamespace)), mMappings(aMappings)
{
}
nsresult
txAttribute::execute(txExecutionState& aEs)
{
nsAutoPtr<txTextHandler> handler(
static_cast<txTextHandler*>(aEs.popResultHandler()));
@@ -187,17 +187,17 @@ txCheckParam::execute(txExecutionState&
}
}
return NS_OK;
}
txConditionalGoto::txConditionalGoto(nsAutoPtr<Expr>&& aCondition,
txInstruction* aTarget)
- : mCondition(Move(aCondition)), mTarget(aTarget)
+ : mCondition(std::move(aCondition)), mTarget(aTarget)
{
}
nsresult
txConditionalGoto::execute(txExecutionState& aEs)
{
bool exprRes;
nsresult rv = mCondition->evaluateToBool(aEs.getEvalContext(), exprRes);
@@ -371,17 +371,17 @@ txCopy::execute(txExecutionState& aEs)
aEs.gotoInstruction(mBailTarget);
}
}
return NS_OK;
}
txCopyOf::txCopyOf(nsAutoPtr<Expr>&& aSelect)
- : mSelect(Move(aSelect))
+ : mSelect(std::move(aSelect))
{
}
nsresult
txCopyOf::execute(txExecutionState& aEs)
{
RefPtr<txAExprResult> exprRes;
nsresult rv = mSelect->evaluate(aEs.getEvalContext(),
@@ -495,17 +495,17 @@ txLoopNodeSet::execute(txExecutionState&
return NS_OK;
}
txLREAttribute::txLREAttribute(int32_t aNamespaceID, nsAtom* aLocalName,
nsAtom* aPrefix, nsAutoPtr<Expr>&& aValue)
: mNamespaceID(aNamespaceID),
mLocalName(aLocalName),
mPrefix(aPrefix),
- mValue(Move(aValue))
+ mValue(std::move(aValue))
{
if (aNamespaceID == kNameSpaceID_None) {
mLowercaseLocalName = TX_ToLowerCaseAtom(aLocalName);
}
}
nsresult
txLREAttribute::execute(txExecutionState& aEs)
@@ -551,22 +551,22 @@ txMessage::execute(txExecutionState& aEs
return mTerminate ? NS_ERROR_XSLT_ABORTED : NS_OK;
}
txNumber::txNumber(txXSLTNumber::LevelType aLevel,
nsAutoPtr<txPattern>&& aCount, nsAutoPtr<txPattern>&& aFrom,
nsAutoPtr<Expr>&& aValue, nsAutoPtr<Expr>&& aFormat,
nsAutoPtr<Expr>&& aGroupingSeparator,
nsAutoPtr<Expr>&& aGroupingSize)
- : mLevel(aLevel), mCount(Move(aCount)),
- mFrom(Move(aFrom)),
- mValue(Move(aValue)),
- mFormat(Move(aFormat)),
- mGroupingSeparator(Move(aGroupingSeparator)),
- mGroupingSize(Move(aGroupingSize))
+ : mLevel(aLevel), mCount(std::move(aCount)),
+ mFrom(std::move(aFrom)),
+ mValue(std::move(aValue)),
+ mFormat(std::move(aFormat)),
+ mGroupingSeparator(std::move(aGroupingSeparator)),
+ mGroupingSize(std::move(aGroupingSize))
{
}
nsresult
txNumber::execute(txExecutionState& aEs)
{
nsAutoString res;
nsresult rv =
@@ -582,17 +582,17 @@ nsresult
txPopParams::execute(txExecutionState& aEs)
{
RefPtr<txParameterMap> paramMap = aEs.popParamMap();
return NS_OK;
}
txProcessingInstruction::txProcessingInstruction(nsAutoPtr<Expr>&& aName)
- : mName(Move(aName))
+ : mName(std::move(aName))
{
}
nsresult
txProcessingInstruction::execute(txExecutionState& aEs)
{
nsAutoPtr<txTextHandler> handler(
static_cast<txTextHandler*>(aEs.popResultHandler()));
@@ -609,17 +609,17 @@ txProcessingInstruction::execute(txExecu
// XXX ErrorReport: bad PI-target
return NS_ERROR_FAILURE;
}
return aEs.mResultHandler->processingInstruction(name, handler->mValue);
}
txPushNewContext::txPushNewContext(nsAutoPtr<Expr>&& aSelect)
- : mSelect(Move(aSelect)), mBailTarget(nullptr)
+ : mSelect(std::move(aSelect)), mBailTarget(nullptr)
{
}
txPushNewContext::~txPushNewContext()
{
}
nsresult
@@ -677,21 +677,21 @@ nsresult
txPushNewContext::addSort(nsAutoPtr<Expr>&& aSelectExpr,
nsAutoPtr<Expr>&& aLangExpr,
nsAutoPtr<Expr>&& aDataTypeExpr,
nsAutoPtr<Expr>&& aOrderExpr,
nsAutoPtr<Expr>&& aCaseOrderExpr)
{
if (SortKey *key = mSortKeys.AppendElement()) {
// workaround for not triggering the Copy Constructor
- key->mSelectExpr = Move(aSelectExpr);
- key->mLangExpr = Move(aLangExpr);
- key->mDataTypeExpr = Move(aDataTypeExpr);
- key->mOrderExpr = Move(aOrderExpr);
- key->mCaseOrderExpr = Move(aCaseOrderExpr);
+ key->mSelectExpr = std::move(aSelectExpr);
+ key->mLangExpr = std::move(aLangExpr);
+ key->mDataTypeExpr = std::move(aDataTypeExpr);
+ key->mOrderExpr = std::move(aOrderExpr);
+ key->mCaseOrderExpr = std::move(aCaseOrderExpr);
return NS_OK;
}
return NS_ERROR_OUT_OF_MEMORY;
}
nsresult
txPushNullTemplateRule::execute(txExecutionState& aEs)
{
@@ -755,17 +755,17 @@ txReturn::execute(txExecutionState& aEs)
{
NS_ASSERTION(!mNext, "instructions exist after txReturn");
aEs.returnFromTemplate();
return NS_OK;
}
txSetParam::txSetParam(const txExpandedName& aName, nsAutoPtr<Expr>&& aValue)
- : mName(aName), mValue(Move(aValue))
+ : mName(aName), mValue(std::move(aValue))
{
}
nsresult
txSetParam::execute(txExecutionState& aEs)
{
nsresult rv = NS_OK;
if (!aEs.mTemplateParams) {
@@ -788,17 +788,17 @@ txSetParam::execute(txExecutionState& aE
rv = aEs.mTemplateParams->bindVariable(mName, exprRes);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
txSetVariable::txSetVariable(const txExpandedName& aName,
nsAutoPtr<Expr>&& aValue)
- : mName(aName), mValue(Move(aValue))
+ : mName(aName), mValue(std::move(aValue))
{
}
nsresult
txSetVariable::execute(txExecutionState& aEs)
{
nsresult rv = NS_OK;
RefPtr<txAExprResult> exprRes;
@@ -814,18 +814,18 @@ txSetVariable::execute(txExecutionState&
}
return aEs.bindVariable(mName, exprRes);
}
txStartElement::txStartElement(nsAutoPtr<Expr>&& aName,
nsAutoPtr<Expr>&& aNamespace,
txNamespaceMap* aMappings)
- : mName(Move(aName)),
- mNamespace(Move(aNamespace)),
+ : mName(std::move(aName)),
+ mNamespace(std::move(aNamespace)),
mMappings(aMappings)
{
}
nsresult
txStartElement::execute(txExecutionState& aEs)
{
nsAutoString name;
@@ -922,17 +922,17 @@ txText::txText(const nsAString& aStr, bo
nsresult
txText::execute(txExecutionState& aEs)
{
return aEs.mResultHandler->characters(mStr, mDOE);
}
txValueOf::txValueOf(nsAutoPtr<Expr>&& aExpr, bool aDOE)
- : mExpr(Move(aExpr)),
+ : mExpr(std::move(aExpr)),
mDOE(aDOE)
{
}
nsresult
txValueOf::execute(txExecutionState& aEs)
{
RefPtr<txAExprResult> exprRes;
--- a/dom/xslt/xslt/txKeyFunctionCall.cpp
+++ b/dom/xslt/xslt/txKeyFunctionCall.cpp
@@ -254,18 +254,18 @@ bool txXSLKey::addKey(nsAutoPtr<txPatter
{
if (!aMatch || !aUse)
return false;
Key* key = mKeys.AppendElement();
if (!key)
return false;
- key->matchPattern = Move(aMatch);
- key->useExpr = Move(aUse);
+ key->matchPattern = std::move(aMatch);
+ key->useExpr = std::move(aUse);
return true;
}
/**
* Indexes a document and adds it to the hash of key values
* @param aRoot Subtree root to index and add
* @param aKeyValueHash Hash to add values to
--- a/dom/xslt/xslt/txRtfHandler.cpp
+++ b/dom/xslt/xslt/txRtfHandler.cpp
@@ -5,17 +5,17 @@
#include "txRtfHandler.h"
#include "mozilla/Move.h"
using mozilla::Move;
txResultTreeFragment::txResultTreeFragment(nsAutoPtr<txResultBuffer>&& aBuffer)
: txAExprResult(nullptr),
- mBuffer(Move(aBuffer))
+ mBuffer(std::move(aBuffer))
{
}
short txResultTreeFragment::getResultType()
{
return RESULT_TREE_FRAGMENT;
}
@@ -56,17 +56,17 @@ nsresult txResultTreeFragment::flushToHa
}
return mBuffer->flushToHandler(aHandler);
}
nsresult
txRtfHandler::getAsRTF(txAExprResult** aResult)
{
- *aResult = new txResultTreeFragment(Move(mBuffer));
+ *aResult = new txResultTreeFragment(std::move(mBuffer));
NS_ADDREF(*aResult);
return NS_OK;
}
nsresult
txRtfHandler::endDocument(nsresult aResult)
{
return NS_OK;
--- a/dom/xslt/xslt/txStylesheet.cpp
+++ b/dom/xslt/xslt/txStylesheet.cpp
@@ -32,17 +32,17 @@ txStylesheet::init()
// Create default templates
// element/root template
mContainerTemplate = new txPushParams;
nsAutoPtr<txNodeTest> nt(new txNodeTypeTest(txNodeTypeTest::NODE_TYPE));
nsAutoPtr<Expr> nodeExpr(new LocationStep(nt, LocationStep::CHILD_AXIS));
nt.forget();
- txPushNewContext* pushContext = new txPushNewContext(Move(nodeExpr));
+ txPushNewContext* pushContext = new txPushNewContext(std::move(nodeExpr));
mContainerTemplate->mNext = pushContext;
txApplyDefaultElementTemplate* applyTemplates =
new txApplyDefaultElementTemplate;
pushContext->mNext = applyTemplates;
txLoopNodeSet* loopNodeSet = new txLoopNodeSet(applyTemplates);
applyTemplates->mNext = loopNodeSet;
@@ -52,17 +52,17 @@ txStylesheet::init()
popParams->mNext = new txReturn();
// attribute/textnode template
nt = new txNodeTypeTest(txNodeTypeTest::NODE_TYPE);
nodeExpr = new LocationStep(nt, LocationStep::SELF_AXIS);
nt.forget();
- mCharactersTemplate = new txValueOf(Move(nodeExpr), false);
+ mCharactersTemplate = new txValueOf(std::move(nodeExpr), false);
mCharactersTemplate->mNext = new txReturn();
// pi/comment/namespace template
mEmptyTemplate = new txReturn();
return NS_OK;
}
@@ -397,20 +397,20 @@ txStylesheet::addTemplate(txTemplateItem
rv = aImportFrame->mMatchableTemplates.set(aTemplate->mMode, newList);
NS_ENSURE_SUCCESS(rv, rv);
templates = newList.forget();
}
// Add the simple patterns to the list of matchable templates, according
// to default priority
- nsAutoPtr<txPattern> simple = Move(aTemplate->mMatch);
+ nsAutoPtr<txPattern> simple = std::move(aTemplate->mMatch);
nsAutoPtr<txPattern> unionPattern;
if (simple->getType() == txPattern::UNION_PATTERN) {
- unionPattern = Move(simple);
+ unionPattern = std::move(simple);
simple = unionPattern->getSubPatternAt(0);
unionPattern->setSubPatternAt(0, nullptr);
}
uint32_t unionPos = 1; // only used when unionPattern is set
while (simple) {
double priority = aTemplate->mPrio;
if (mozilla::IsNaN(priority)) {
@@ -425,17 +425,17 @@ txStylesheet::addTemplate(txTemplateItem
break;
}
}
MatchableTemplate* nt = templates->InsertElementAt(i);
NS_ENSURE_TRUE(nt, NS_ERROR_OUT_OF_MEMORY);
nt->mFirstInstruction = instr;
- nt->mMatch = Move(simple);
+ nt->mMatch = std::move(simple);
nt->mPriority = priority;
if (unionPattern) {
simple = unionPattern->getSubPatternAt(unionPos);
if (simple) {
unionPattern->setSubPatternAt(unionPos, nullptr);
}
++unionPos;
@@ -536,18 +536,18 @@ txStylesheet::addAttributeSet(txAttribut
nsresult
txStylesheet::addGlobalVariable(txVariableItem* aVariable)
{
if (mGlobalVariables.get(aVariable->mName)) {
return NS_OK;
}
nsAutoPtr<GlobalVariable> var(
- new GlobalVariable(Move(aVariable->mValue),
- Move(aVariable->mFirstInstruction),
+ new GlobalVariable(std::move(aVariable->mValue),
+ std::move(aVariable->mFirstInstruction),
aVariable->mIsParam));
nsresult rv = mGlobalVariables.add(aVariable->mName, var);
NS_ENSURE_SUCCESS(rv, rv);
var.forget();
return NS_OK;
@@ -563,17 +563,17 @@ txStylesheet::addKey(const txExpandedNam
if (!xslKey) {
xslKey = new txXSLKey(aName);
rv = mKeys.add(aName, xslKey);
if (NS_FAILED(rv)) {
delete xslKey;
return rv;
}
}
- if (!xslKey->addKey(Move(aMatch), Move(aUse))) {
+ if (!xslKey->addKey(std::move(aMatch), std::move(aUse))) {
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
nsresult
txStylesheet::addDecimalFormat(const txExpandedName& aName,
nsAutoPtr<txDecimalFormat>&& aFormat)
@@ -600,13 +600,13 @@ txStylesheet::ImportFrame::~ImportFrame(
while (tlIter.hasNext()) {
delete static_cast<txToplevelItem*>(tlIter.next());
}
}
txStylesheet::GlobalVariable::GlobalVariable(nsAutoPtr<Expr>&& aExpr,
nsAutoPtr<txInstruction>&& aInstr,
bool aIsParam)
- : mExpr(Move(aExpr)),
- mFirstInstruction(Move(aInstr)),
+ : mExpr(std::move(aExpr)),
+ mFirstInstruction(std::move(aInstr)),
mIsParam(aIsParam)
{
}
--- a/dom/xslt/xslt/txStylesheetCompileHandlers.cpp
+++ b/dom/xslt/xslt/txStylesheetCompileHandlers.cpp
@@ -108,17 +108,17 @@ parseUseAttrSets(txStylesheetAttr* aAttr
nsWhitespaceTokenizer tok(attr->mValue);
while (tok.hasMoreTokens()) {
txExpandedName name;
rv = name.init(tok.nextToken(), aState.mElementContext->mMappings,
false);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txInstruction> instr(new txInsertAttrSet(name));
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
static nsresult
parseExcludeResultPrefixes(txStylesheetAttr* aAttributes,
int32_t aAttrCount,
@@ -516,17 +516,17 @@ txFnStartLREStylesheet(int32_t aNamespac
nsresult rv = getStyleAttr(aAttributes, aAttrCount, kNameSpaceID_XSLT,
nsGkAtoms::version, true, &attr);
NS_ENSURE_SUCCESS(rv, rv);
txExpandedName nullExpr;
double prio = UnspecifiedNaN<double>();
nsAutoPtr<txPattern> match(new txRootPattern());
- nsAutoPtr<txTemplateItem> templ(new txTemplateItem(Move(match), nullExpr,
+ nsAutoPtr<txTemplateItem> templ(new txTemplateItem(std::move(match), nullExpr,
nullExpr, prio));
aState.openInstructionContainer(templ);
rv = aState.addToplevelItem(templ);
NS_ENSURE_SUCCESS(rv, rv);
templ.forget();
rv = aState.pushHandlerTable(gTxTemplateHandler);
@@ -540,17 +540,17 @@ static nsresult
txFnEndLREStylesheet(txStylesheetCompilerState& aState)
{
nsresult rv = txFnEndLRE(aState);
NS_ENSURE_SUCCESS(rv, rv);
aState.popHandlerTable();
nsAutoPtr<txInstruction> instr(new txReturn());
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
aState.closeInstructionContainer();
return NS_OK;
}
static nsresult
@@ -642,17 +642,17 @@ txFnStartAttributeSet(int32_t aNamespace
}
static nsresult
txFnEndAttributeSet(txStylesheetCompilerState& aState)
{
aState.popHandlerTable();
nsAutoPtr<txInstruction> instr(new txReturn());
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
aState.closeInstructionContainer();
return NS_OK;
}
@@ -716,17 +716,17 @@ txFnStartDecimalFormat(int32_t aNamespac
rv = getCharAttr(aAttributes, aAttrCount, nsGkAtoms::digit,
false, aState, format->mDigit);
NS_ENSURE_SUCCESS(rv, rv);
rv = getCharAttr(aAttributes, aAttrCount, nsGkAtoms::patternSeparator,
false, aState, format->mPatternSeparator);
NS_ENSURE_SUCCESS(rv, rv);
- rv = aState.mStylesheet->addDecimalFormat(name, Move(format));
+ rv = aState.mStylesheet->addDecimalFormat(name, std::move(format));
NS_ENSURE_SUCCESS(rv, rv);
return aState.pushHandlerTable(gTxIgnoreHandler);
}
static nsresult
txFnEndDecimalFormat(txStylesheetCompilerState& aState)
{
@@ -828,17 +828,17 @@ txFnStartKey(int32_t aNamespaceID,
nsAutoPtr<Expr> use;
rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::use, true,
aState, use);
NS_ENSURE_SUCCESS(rv, rv);
aState.mDisAllowed = 0;
- rv = aState.mStylesheet->addKey(name, Move(match), Move(use));
+ rv = aState.mStylesheet->addKey(name, std::move(match), std::move(use));
NS_ENSURE_SUCCESS(rv, rv);
return aState.pushHandlerTable(gTxIgnoreHandler);
}
static nsresult
txFnEndKey(txStylesheetCompilerState& aState)
{
@@ -1097,34 +1097,34 @@ txFnStartTemplate(int32_t aNamespaceID,
false, aState, prio);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txPattern> match;
rv = getPatternAttr(aAttributes, aAttrCount, nsGkAtoms::match,
name.isNull(), aState, match);
NS_ENSURE_SUCCESS(rv, rv);
- nsAutoPtr<txTemplateItem> templ(new txTemplateItem(Move(match), name, mode,
+ nsAutoPtr<txTemplateItem> templ(new txTemplateItem(std::move(match), name, mode,
prio));
aState.openInstructionContainer(templ);
rv = aState.addToplevelItem(templ);
NS_ENSURE_SUCCESS(rv, rv);
templ.forget();
return aState.pushHandlerTable(gTxParamHandler);
}
static nsresult
txFnEndTemplate(txStylesheetCompilerState& aState)
{
aState.popHandlerTable();
nsAutoPtr<txInstruction> instr(new txReturn());
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
aState.closeInstructionContainer();
return NS_OK;
}
// xsl:variable, xsl:param
@@ -1143,17 +1143,17 @@ txFnStartTopVariable(int32_t aNamespaceI
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<Expr> select;
rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, false,
aState, select);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txVariableItem> var(
- new txVariableItem(name, Move(select),
+ new txVariableItem(name, std::move(select),
aLocalName == nsGkAtoms::param));
aState.openInstructionContainer(var);
rv = aState.pushPtr(var, aState.eVariableItem);
NS_ENSURE_SUCCESS(rv, rv);
if (var->mValue) {
// XXX should be gTxErrorHandler?
rv = aState.pushHandlerTable(gTxIgnoreHandler);
@@ -1184,17 +1184,17 @@ txFnEndTopVariable(txStylesheetCompilerS
// No children were found.
NS_ASSERTION(!var->mValue,
"There shouldn't be a select-expression here");
var->mValue = new txLiteralExpr(EmptyString());
}
else if (!var->mValue) {
// If we don't have a select-expression there mush be children.
nsAutoPtr<txInstruction> instr(new txReturn());
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
}
aState.closeInstructionContainer();
return NS_OK;
}
@@ -1241,17 +1241,17 @@ txFnStartLRE(int32_t aNamespaceID,
txStylesheetAttr* aAttributes,
int32_t aAttrCount,
txStylesheetCompilerState& aState)
{
nsresult rv = NS_OK;
nsAutoPtr<txInstruction> instr(new txStartLREElement(aNamespaceID,
aLocalName, aPrefix));
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
rv = parseExcludeResultPrefixes(aAttributes, aAttrCount, kNameSpaceID_XSLT);
NS_ENSURE_SUCCESS(rv, rv);
rv = parseUseAttrSets(aAttributes, aAttrCount, true, aState);
NS_ENSURE_SUCCESS(rv, rv);
@@ -1269,46 +1269,46 @@ txFnStartLRE(int32_t aNamespaceID,
}
nsAutoPtr<Expr> avt;
rv = txExprParser::createAVT(attr->mValue, &aState,
getter_Transfers(avt));
NS_ENSURE_SUCCESS(rv, rv);
instr = new txLREAttribute(attr->mNamespaceID, attr->mLocalName,
- attr->mPrefix, Move(avt));
- rv = aState.addInstruction(Move(instr));
+ attr->mPrefix, std::move(avt));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
static nsresult
txFnEndLRE(txStylesheetCompilerState& aState)
{
nsAutoPtr<txInstruction> instr(new txEndElement);
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
/*
"LRE text"
txText
*/
static nsresult
txFnText(const nsAString& aStr, txStylesheetCompilerState& aState)
{
TX_RETURN_IF_WHITESPACE(aStr, aState);
nsAutoPtr<txInstruction> instr(new txText(aStr, false));
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
/*
xsl:apply-imports
@@ -1321,21 +1321,21 @@ txFnStartApplyImports(int32_t aNamespace
nsAtom* aPrefix,
txStylesheetAttr* aAttributes,
int32_t aAttrCount,
txStylesheetCompilerState& aState)
{
nsresult rv = NS_OK;
nsAutoPtr<txInstruction> instr(new txApplyImportsStart);
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
instr = new txApplyImportsEnd;
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return aState.pushHandlerTable(gTxIgnoreHandler);
}
static nsresult
txFnEndApplyImports(txStylesheetCompilerState& aState)
{
@@ -1360,17 +1360,17 @@ txFnStartApplyTemplates(int32_t aNamespa
nsAtom* aPrefix,
txStylesheetAttr* aAttributes,
int32_t aAttrCount,
txStylesheetCompilerState& aState)
{
nsresult rv = NS_OK;
nsAutoPtr<txInstruction> instr(new txPushParams);
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
txExpandedName mode;
rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::mode, false,
aState, mode);
NS_ENSURE_SUCCESS(rv, rv);
instr = new txApplyTemplates(mode);
@@ -1386,17 +1386,17 @@ txFnStartApplyTemplates(int32_t aNamespa
if (!select) {
nsAutoPtr<txNodeTest> nt(
new txNodeTypeTest(txNodeTypeTest::NODE_TYPE));
select = new LocationStep(nt, LocationStep::CHILD_AXIS);
nt.forget();
}
- nsAutoPtr<txPushNewContext> pushcontext( new txPushNewContext(Move(select)));
+ nsAutoPtr<txPushNewContext> pushcontext( new txPushNewContext(std::move(select)));
rv = aState.pushSorter(pushcontext);
NS_ENSURE_SUCCESS(rv, rv);
rv = aState.pushObject(pushcontext);
NS_ENSURE_SUCCESS(rv, rv);
pushcontext.forget();
@@ -1406,33 +1406,33 @@ txFnStartApplyTemplates(int32_t aNamespa
static nsresult
txFnEndApplyTemplates(txStylesheetCompilerState& aState)
{
aState.popHandlerTable();
txPushNewContext* pushcontext =
static_cast<txPushNewContext*>(aState.popObject());
nsAutoPtr<txInstruction> instr(pushcontext); // txPushNewContext
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
aState.popSorter();
instr = static_cast<txInstruction*>(aState.popObject()); // txApplyTemplates
nsAutoPtr<txLoopNodeSet> loop(new txLoopNodeSet(instr));
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
instr = loop.forget();
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
instr = new txPopParams;
pushcontext->mBailTarget = instr;
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
/*
xsl:attribute
@@ -1446,30 +1446,30 @@ txFnStartAttribute(int32_t aNamespaceID,
nsAtom* aPrefix,
txStylesheetAttr* aAttributes,
int32_t aAttrCount,
txStylesheetCompilerState& aState)
{
nsresult rv = NS_OK;
nsAutoPtr<txInstruction> instr(new txPushStringHandler(true));
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<Expr> name;
rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::name, true,
aState, name);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<Expr> nspace;
rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::_namespace, false,
aState, nspace);
NS_ENSURE_SUCCESS(rv, rv);
- instr = new txAttribute(Move(name), Move(nspace),
+ instr = new txAttribute(std::move(name), std::move(nspace),
aState.mElementContext->mMappings);
rv = aState.pushObject(instr);
NS_ENSURE_SUCCESS(rv, rv);
instr.forget();
// We need to push the template-handler since the current might be
// the attributeset-handler
@@ -1477,17 +1477,17 @@ txFnStartAttribute(int32_t aNamespaceID,
}
static nsresult
txFnEndAttribute(txStylesheetCompilerState& aState)
{
aState.popHandlerTable();
nsAutoPtr<txInstruction> instr(static_cast<txInstruction*>
(aState.popObject()));
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
/*
xsl:call-template
@@ -1502,17 +1502,17 @@ txFnStartCallTemplate(int32_t aNamespace
nsAtom* aPrefix,
txStylesheetAttr* aAttributes,
int32_t aAttrCount,
txStylesheetCompilerState& aState)
{
nsresult rv = NS_OK;
nsAutoPtr<txInstruction> instr(new txPushParams);
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
txExpandedName name;
rv = getQNameAttr(aAttributes, aAttrCount, nsGkAtoms::name, true,
aState, name);
NS_ENSURE_SUCCESS(rv, rv);
instr = new txCallTemplate(name);
@@ -1526,21 +1526,21 @@ txFnStartCallTemplate(int32_t aNamespace
static nsresult
txFnEndCallTemplate(txStylesheetCompilerState& aState)
{
aState.popHandlerTable();
// txCallTemplate
nsAutoPtr<txInstruction> instr(static_cast<txInstruction*>(aState.popObject()));
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
instr = new txPopParams;
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
/*
xsl:choose
@@ -1597,27 +1597,27 @@ static nsresult
txFnStartComment(int32_t aNamespaceID,
nsAtom* aLocalName,
nsAtom* aPrefix,
txStylesheetAttr* aAttributes,
int32_t aAttrCount,
txStylesheetCompilerState& aState)
{
nsAutoPtr<txInstruction> instr(new txPushStringHandler(true));
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
static nsresult
txFnEndComment(txStylesheetCompilerState& aState)
{
nsAutoPtr<txInstruction> instr(new txComment);
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
/*
xsl:copy
@@ -1635,30 +1635,30 @@ txFnStartCopy(int32_t aNamespaceID,
int32_t aAttrCount,
txStylesheetCompilerState& aState)
{
nsAutoPtr<txCopy> copy(new txCopy);
nsresult rv = aState.pushPtr(copy, aState.eCopy);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txInstruction> instr(copy.forget());
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
rv = parseUseAttrSets(aAttributes, aAttrCount, false, aState);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
static nsresult
txFnEndCopy(txStylesheetCompilerState& aState)
{
nsAutoPtr<txInstruction> instr(new txEndElement);
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
txCopy* copy = static_cast<txCopy*>(aState.popPtr(aState.eCopy));
rv = aState.addGotoTarget(©->mBailTarget);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
@@ -1678,18 +1678,18 @@ txFnStartCopyOf(int32_t aNamespaceID,
{
nsresult rv = NS_OK;
nsAutoPtr<Expr> select;
rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, true,
aState, select);
NS_ENSURE_SUCCESS(rv, rv);
- nsAutoPtr<txInstruction> instr(new txCopyOf(Move(select)));
- rv = aState.addInstruction(Move(instr));
+ nsAutoPtr<txInstruction> instr(new txCopyOf(std::move(select)));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return aState.pushHandlerTable(gTxIgnoreHandler);
}
static nsresult
txFnEndCopyOf(txStylesheetCompilerState& aState)
{
@@ -1721,32 +1721,32 @@ txFnStartElement(int32_t aNamespaceID,
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<Expr> nspace;
rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::_namespace, false,
aState, nspace);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txInstruction> instr(
- new txStartElement(Move(name), Move(nspace),
+ new txStartElement(std::move(name), std::move(nspace),
aState.mElementContext->mMappings));
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
rv = parseUseAttrSets(aAttributes, aAttrCount, false, aState);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
static nsresult
txFnEndElement(txStylesheetCompilerState& aState)
{
nsAutoPtr<txInstruction> instr(new txEndElement);
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
/*
xsl:fallback
@@ -1794,48 +1794,48 @@ txFnStartForEach(int32_t aNamespaceID,
{
nsresult rv = NS_OK;
nsAutoPtr<Expr> select;
rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, true,
aState, select);
NS_ENSURE_SUCCESS(rv, rv);
- nsAutoPtr<txPushNewContext> pushcontext(new txPushNewContext(Move(select)));
+ nsAutoPtr<txPushNewContext> pushcontext(new txPushNewContext(std::move(select)));
rv = aState.pushPtr(pushcontext, aState.ePushNewContext);
NS_ENSURE_SUCCESS(rv, rv);
rv = aState.pushSorter(pushcontext);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txInstruction> instr(pushcontext.forget());
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
instr = new txPushNullTemplateRule;
rv = aState.pushPtr(instr, aState.ePushNullTemplateRule);
NS_ENSURE_SUCCESS(rv, rv);
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return aState.pushHandlerTable(gTxForEachHandler);
}
static nsresult
txFnEndForEach(txStylesheetCompilerState& aState)
{
aState.popHandlerTable();
// This is a txPushNullTemplateRule
txInstruction* pnullrule =
static_cast<txInstruction*>(aState.popPtr(aState.ePushNullTemplateRule));
nsAutoPtr<txInstruction> instr(new txLoopNodeSet(pnullrule));
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
aState.popSorter();
txPushNewContext* pushcontext =
static_cast<txPushNewContext*>(aState.popPtr(aState.ePushNewContext));
aState.addGotoTarget(&pushcontext->mBailTarget);
return NS_OK;
@@ -1882,23 +1882,23 @@ txFnStartIf(int32_t aNamespaceID,
{
nsresult rv = NS_OK;
nsAutoPtr<Expr> test;
rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::test, true,
aState, test);
NS_ENSURE_SUCCESS(rv, rv);
- nsAutoPtr<txConditionalGoto> condGoto(new txConditionalGoto(Move(test),
+ nsAutoPtr<txConditionalGoto> condGoto(new txConditionalGoto(std::move(test),
nullptr));
rv = aState.pushPtr(condGoto, aState.eConditionalGoto);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txInstruction> instr(condGoto.forget());
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
static nsresult
txFnEndIf(txStylesheetCompilerState& aState)
{
@@ -1918,17 +1918,17 @@ static nsresult
txFnStartMessage(int32_t aNamespaceID,
nsAtom* aLocalName,
nsAtom* aPrefix,
txStylesheetAttr* aAttributes,
int32_t aAttrCount,
txStylesheetCompilerState& aState)
{
nsAutoPtr<txInstruction> instr(new txPushStringHandler(false));
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
txThreeState term;
rv = getYesNoAttr(aAttributes, aAttrCount, nsGkAtoms::terminate,
false, aState, term);
NS_ENSURE_SUCCESS(rv, rv);
instr = new txMessage(term == eTrue);
@@ -1939,17 +1939,17 @@ txFnStartMessage(int32_t aNamespaceID,
return NS_OK;
}
static nsresult
txFnEndMessage(txStylesheetCompilerState& aState)
{
nsAutoPtr<txInstruction> instr(static_cast<txInstruction*>(aState.popObject()));
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
/*
xsl:number
@@ -2016,21 +2016,21 @@ txFnStartNumber(int32_t aNamespaceID,
false, aState, groupingSeparator);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<Expr> groupingSize;
rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::groupingSize,
false, aState, groupingSize);
NS_ENSURE_SUCCESS(rv, rv);
- nsAutoPtr<txInstruction> instr(new txNumber(level, Move(count), Move(from),
- Move(value), Move(format),
- Move(groupingSeparator),
- Move(groupingSize)));
- rv = aState.addInstruction(Move(instr));
+ nsAutoPtr<txInstruction> instr(new txNumber(level, std::move(count), std::move(from),
+ std::move(value), std::move(format),
+ std::move(groupingSeparator),
+ std::move(groupingSize)));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return aState.pushHandlerTable(gTxIgnoreHandler);
}
static nsresult
txFnEndNumber(txStylesheetCompilerState& aState)
{
@@ -2090,25 +2090,25 @@ txFnStartParam(int32_t aNamespaceID,
nsAutoPtr<txCheckParam> checkParam(new txCheckParam(name));
NS_ENSURE_SUCCESS(rv, rv);
rv = aState.pushPtr(checkParam, aState.eCheckParam);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txInstruction> instr(checkParam.forget());
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<Expr> select;
rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, false,
aState, select);
NS_ENSURE_SUCCESS(rv, rv);
- nsAutoPtr<txSetVariable> var(new txSetVariable(name, Move(select)));
+ nsAutoPtr<txSetVariable> var(new txSetVariable(name, std::move(select)));
if (var->mValue) {
// XXX should be gTxErrorHandler?
rv = aState.pushHandlerTable(gTxIgnoreHandler);
NS_ENSURE_SUCCESS(rv, rv);
}
else {
rv = aState.pushHandlerTable(gTxVariableHandler);
NS_ENSURE_SUCCESS(rv, rv);
@@ -2136,17 +2136,17 @@ txFnEndParam(txStylesheetCompilerState&
"There shouldn't be a select-expression here");
var->mValue = new txLiteralExpr(EmptyString());
}
nsresult rv = aState.addVariable(var->mName);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txInstruction> instr(var.forget());
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
txCheckParam* checkParam =
static_cast<txCheckParam*>(aState.popPtr(aState.eCheckParam));
aState.addGotoTarget(&checkParam->mBailTarget);
return NS_OK;
}
@@ -2162,39 +2162,39 @@ static nsresult
txFnStartPI(int32_t aNamespaceID,
nsAtom* aLocalName,
nsAtom* aPrefix,
txStylesheetAttr* aAttributes,
int32_t aAttrCount,
txStylesheetCompilerState& aState)
{
nsAutoPtr<txInstruction> instr(new txPushStringHandler(true));
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<Expr> name;
rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::name, true,
aState, name);
NS_ENSURE_SUCCESS(rv, rv);
- instr = new txProcessingInstruction(Move(name));
+ instr = new txProcessingInstruction(std::move(name));
rv = aState.pushObject(instr);
NS_ENSURE_SUCCESS(rv, rv);
instr.forget();
return NS_OK;
}
static nsresult
txFnEndPI(txStylesheetCompilerState& aState)
{
nsAutoPtr<txInstruction> instr(static_cast<txInstruction*>
(aState.popObject()));
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
/*
xsl:sort
@@ -2239,18 +2239,18 @@ txFnStartSort(int32_t aNamespaceID,
aState, order);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<Expr> caseOrder;
rv = getAVTAttr(aAttributes, aAttrCount, nsGkAtoms::caseOrder, false,
aState, caseOrder);
NS_ENSURE_SUCCESS(rv, rv);
- rv = aState.mSorter->addSort(Move(select), Move(lang), Move(dataType),
- Move(order), Move(caseOrder));
+ rv = aState.mSorter->addSort(std::move(select), std::move(lang), std::move(dataType),
+ std::move(order), std::move(caseOrder));
NS_ENSURE_SUCCESS(rv, rv);
return aState.pushHandlerTable(gTxIgnoreHandler);
}
static nsresult
txFnEndSort(txStylesheetCompilerState& aState)
{
@@ -2293,17 +2293,17 @@ txFnEndText(txStylesheetCompilerState& a
aState.popHandlerTable();
return NS_OK;
}
static nsresult
txFnTextText(const nsAString& aStr, txStylesheetCompilerState& aState)
{
nsAutoPtr<txInstruction> instr(new txText(aStr, aState.mDOE));
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
/*
xsl:value-of
@@ -2325,18 +2325,18 @@ txFnStartValueOf(int32_t aNamespaceID,
doe);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<Expr> select;
rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, true,
aState, select);
NS_ENSURE_SUCCESS(rv, rv);
- nsAutoPtr<txInstruction> instr(new txValueOf(Move(select), doe == eTrue));
- rv = aState.addInstruction(Move(instr));
+ nsAutoPtr<txInstruction> instr(new txValueOf(std::move(select), doe == eTrue));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return aState.pushHandlerTable(gTxIgnoreHandler);
}
static nsresult
txFnEndValueOf(txStylesheetCompilerState& aState)
{
@@ -2366,17 +2366,17 @@ txFnStartVariable(int32_t aNamespaceID,
aState, name);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<Expr> select;
rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, false,
aState, select);
NS_ENSURE_SUCCESS(rv, rv);
- nsAutoPtr<txSetVariable> var(new txSetVariable(name, Move(select)));
+ nsAutoPtr<txSetVariable> var(new txSetVariable(name, std::move(select)));
if (var->mValue) {
// XXX should be gTxErrorHandler?
rv = aState.pushHandlerTable(gTxIgnoreHandler);
NS_ENSURE_SUCCESS(rv, rv);
}
else {
rv = aState.pushHandlerTable(gTxVariableHandler);
NS_ENSURE_SUCCESS(rv, rv);
@@ -2405,46 +2405,46 @@ txFnEndVariable(txStylesheetCompilerStat
"There shouldn't be a select-expression here");
var->mValue = new txLiteralExpr(EmptyString());
}
nsresult rv = aState.addVariable(var->mName);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txInstruction> instr(var.forget());
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
static nsresult
txFnStartElementStartRTF(int32_t aNamespaceID,
nsAtom* aLocalName,
nsAtom* aPrefix,
txStylesheetAttr* aAttributes,
int32_t aAttrCount,
txStylesheetCompilerState& aState)
{
nsAutoPtr<txInstruction> instr(new txPushRTFHandler);
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
aState.mHandlerTable = gTxTemplateHandler;
return NS_XSLT_GET_NEW_HANDLER;
}
static nsresult
txFnTextStartRTF(const nsAString& aStr, txStylesheetCompilerState& aState)
{
TX_RETURN_IF_WHITESPACE(aStr, aState);
nsAutoPtr<txInstruction> instr(new txPushRTFHandler);
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
aState.mHandlerTable = gTxTemplateHandler;
return NS_XSLT_GET_NEW_HANDLER;
}
/*
@@ -2462,38 +2462,38 @@ txFnStartWhen(int32_t aNamespaceID,
{
nsresult rv = NS_OK;
nsAutoPtr<Expr> test;
rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::test, true,
aState, test);
NS_ENSURE_SUCCESS(rv, rv);
- nsAutoPtr<txConditionalGoto> condGoto(new txConditionalGoto(Move(test),
+ nsAutoPtr<txConditionalGoto> condGoto(new txConditionalGoto(std::move(test),
nullptr));
rv = aState.pushPtr(condGoto, aState.eConditionalGoto);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txInstruction> instr(condGoto.forget());
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return aState.pushHandlerTable(gTxTemplateHandler);
}
static nsresult
txFnEndWhen(txStylesheetCompilerState& aState)
{
aState.popHandlerTable();
nsAutoPtr<txGoTo> gotoinstr(new txGoTo(nullptr));
nsresult rv = aState.mChooseGotoList->add(gotoinstr);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<txInstruction> instr(gotoinstr.forget());
- rv = aState.addInstruction(Move(instr));
+ rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
txConditionalGoto* condGoto =
static_cast<txConditionalGoto*>(aState.popPtr(aState.eConditionalGoto));
rv = aState.addGotoTarget(&condGoto->mTarget);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
@@ -2521,17 +2521,17 @@ txFnStartWithParam(int32_t aNamespaceID,
aState, name);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoPtr<Expr> select;
rv = getExprAttr(aAttributes, aAttrCount, nsGkAtoms::select, false,
aState, select);
NS_ENSURE_SUCCESS(rv, rv);
- nsAutoPtr<txSetParam> var(new txSetParam(name, Move(select)));
+ nsAutoPtr<txSetParam> var(new txSetParam(name, std::move(select)));
if (var->mValue) {
// XXX should be gTxErrorHandler?
rv = aState.pushHandlerTable(gTxIgnoreHandler);
NS_ENSURE_SUCCESS(rv, rv);
}
else {
rv = aState.pushHandlerTable(gTxVariableHandler);
NS_ENSURE_SUCCESS(rv, rv);
@@ -2555,17 +2555,17 @@ txFnEndWithParam(txStylesheetCompilerSta
if (prev == gTxVariableHandler) {
// No children were found.
NS_ASSERTION(!var->mValue,
"There shouldn't be a select-expression here");
var->mValue = new txLiteralExpr(EmptyString());
}
nsAutoPtr<txInstruction> instr(var.forget());
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
/*
Unknown instruction
@@ -2595,17 +2595,17 @@ txFnStartUnknownInstruction(int32_t aNam
static nsresult
txFnEndUnknownInstruction(txStylesheetCompilerState& aState)
{
aState.popHandlerTable();
if (aState.mSearchingForFallback) {
nsAutoPtr<txInstruction> instr(new txErrorInstruction());
- nsresult rv = aState.addInstruction(Move(instr));
+ nsresult rv = aState.addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
}
aState.mSearchingForFallback = false;
return NS_OK;
}
--- a/dom/xslt/xslt/txStylesheetCompiler.cpp
+++ b/dom/xslt/xslt/txStylesheetCompiler.cpp
@@ -327,17 +327,17 @@ txStylesheetCompiler::endElement()
nsresult rv = flushCharacters();
NS_ENSURE_SUCCESS(rv, rv);
int32_t i;
for (i = mInScopeVariables.Length() - 1; i >= 0; --i) {
txInScopeVariable* var = mInScopeVariables[i];
if (!--(var->mLevel)) {
nsAutoPtr<txInstruction> instr(new txRemoveVariable(var->mName));
- rv = addInstruction(Move(instr));
+ rv = addInstruction(std::move(instr));
NS_ENSURE_SUCCESS(rv, rv);
mInScopeVariables.RemoveElementAt(i);
delete var;
}
}
const txElementHandler* handler =
@@ -475,17 +475,17 @@ txStylesheetCompiler::ensureNewElementCo
}
nsAutoPtr<txElementContext>
context(new txElementContext(*mElementContext));
nsresult rv = pushObject(mElementContext);
NS_ENSURE_SUCCESS(rv, rv);
mElementContext.forget();
- mElementContext = Move(context);
+ mElementContext = std::move(context);
return NS_OK;
}
nsresult
txStylesheetCompiler::maybeDoneCompiling()
{
if (!mDoneWithThisStylesheet || !mChildCompilerList.IsEmpty()) {
--- a/dom/xslt/xslt/txToplevelItems.cpp
+++ b/dom/xslt/xslt/txToplevelItems.cpp
@@ -37,22 +37,22 @@ txStripSpaceItem::addStripSpaceTest(txSt
return NS_OK;
}
TX_IMPL_GETTYPE(txTemplateItem, txToplevelItem::templ)
txTemplateItem::txTemplateItem(nsAutoPtr<txPattern>&& aMatch,
const txExpandedName& aName,
const txExpandedName& aMode, double aPrio)
- : mMatch(Move(aMatch)), mName(aName),
+ : mMatch(std::move(aMatch)), mName(aName),
mMode(aMode), mPrio(aPrio)
{
}
TX_IMPL_GETTYPE(txVariableItem, txToplevelItem::variable)
txVariableItem::txVariableItem(const txExpandedName& aName,
nsAutoPtr<Expr>&& aValue,
bool aIsParam)
- : mName(aName), mValue(Move(aValue)),
+ : mName(aName), mValue(std::move(aValue)),
mIsParam(aIsParam)
{
}
--- a/dom/xslt/xslt/txUnknownHandler.cpp
+++ b/dom/xslt/xslt/txUnknownHandler.cpp
@@ -191,11 +191,11 @@ nsresult txUnknownHandler::createHandler
// flushing a buffer to mEs->mResultHandler.
mEs->mObsoleteHandler = this;
mFlushed = true;
// Let go of out buffer as soon as we're done flushing it, we're not going
// to need it anymore from this point on (all hooks get forwarded to
// mEs->mResultHandler.
- nsAutoPtr<txResultBuffer> buffer(Move(mBuffer));
+ nsAutoPtr<txResultBuffer> buffer(std::move(mBuffer));
return buffer->flushToHandler(mEs->mResultHandler);
}
--- a/dom/xul/nsXULPrototypeCache.cpp
+++ b/dom/xul/nsXULPrototypeCache.cpp
@@ -351,17 +351,17 @@ nsXULPrototypeCache::GetInputStream(nsIU
StartupCache* sc = StartupCache::GetSingleton();
if (!sc)
return NS_ERROR_NOT_AVAILABLE;
rv = sc->GetBuffer(spec.get(), &buf, &len);
if (NS_FAILED(rv))
return NS_ERROR_NOT_AVAILABLE;
- rv = NewObjectInputStreamFromBuffer(Move(buf), len, getter_AddRefs(ois));
+ rv = NewObjectInputStreamFromBuffer(std::move(buf), len, getter_AddRefs(ois));
NS_ENSURE_SUCCESS(rv, rv);
mInputStreamTable.Put(uri, ois);
ois.forget(stream);
return NS_OK;
}
@@ -420,17 +420,17 @@ nsXULPrototypeCache::FinishOutputStream(
rv = NewBufferFromStorageStream(storageStream, &buf, &len);
NS_ENSURE_SUCCESS(rv, rv);
if (!mStartupCacheURITable.GetEntry(uri)) {
nsAutoCString spec(kXULCachePrefix);
rv = PathifyURI(uri, spec);
if (NS_FAILED(rv))
return NS_ERROR_NOT_AVAILABLE;
- rv = sc->PutBuffer(spec.get(), Move(buf), len);
+ rv = sc->PutBuffer(spec.get(), std::move(buf), len);
if (NS_SUCCEEDED(rv)) {
mOutputStreamTable.Remove(uri);
mStartupCacheURITable.PutEntry(uri);
}
}
return rv;
}
@@ -503,17 +503,17 @@ nsXULPrototypeCache::BeginCaching(nsIURI
nsAutoCString fileChromePath, fileLocale;
UniquePtr<char[]> buf;
uint32_t len, amtRead;
nsCOMPtr<nsIObjectInputStream> objectInput;
rv = startupCache->GetBuffer(kXULCacheInfoKey, &buf, &len);
if (NS_SUCCEEDED(rv))
- rv = NewObjectInputStreamFromBuffer(Move(buf), len,
+ rv = NewObjectInputStreamFromBuffer(std::move(buf), len,
getter_AddRefs(objectInput));
if (NS_SUCCEEDED(rv)) {
rv = objectInput->ReadCString(fileLocale);
tmp = objectInput->ReadCString(fileChromePath);
if (NS_FAILED(tmp)) {
rv = tmp;
}
@@ -565,17 +565,17 @@ nsXULPrototypeCache::BeginCaching(nsIURI
rv = NS_ERROR_FILE_TOO_BIG;
}
}
if (NS_SUCCEEDED(rv)) {
buf = MakeUnique<char[]>(len);
rv = inputStream->Read(buf.get(), len, &amtRead);
if (NS_SUCCEEDED(rv) && len == amtRead)
- rv = startupCache->PutBuffer(kXULCacheInfoKey, Move(buf), len);
+ rv = startupCache->PutBuffer(kXULCacheInfoKey, std::move(buf), len);
else {
rv = NS_ERROR_UNEXPECTED;
}
}
// Failed again, just bail.
if (NS_FAILED(rv)) {
startupCache->InvalidateCache();
--- a/editor/libeditor/EditorBase.cpp
+++ b/editor/libeditor/EditorBase.cpp
@@ -737,17 +737,17 @@ EditorBase::DoTransaction(nsITransaction
return DoTransaction(nullptr, aTxn);
}
nsresult
EditorBase::DoTransaction(Selection* aSelection, nsITransaction* aTxn)
{
if (mPlaceholderBatch && !mPlaceholderTransaction) {
mPlaceholderTransaction =
- PlaceholderTransaction::Create(*this, mPlaceholderName, Move(mSelState));
+ PlaceholderTransaction::Create(*this, mPlaceholderName, std::move(mSelState));
MOZ_ASSERT(mSelState.isNothing());
// We will recurse, but will not hit this case in the nested call
DoTransaction(mPlaceholderTransaction);
if (mTransactionManager) {
nsCOMPtr<nsITransaction> topTransaction =
mTransactionManager->PeekUndoStack();
--- a/editor/libeditor/HTMLAbsPositionEditor.cpp
+++ b/editor/libeditor/HTMLAbsPositionEditor.cpp
@@ -270,18 +270,18 @@ HTMLEditor::HideGrabber()
}
// get the presshell's document observer interface.
nsCOMPtr<nsIPresShell> ps = GetPresShell();
// We allow the pres shell to be null; when it is, we presume there
// are no document observers to notify, but we still want to
// UnbindFromTree.
- DeleteRefToAnonymousNode(Move(mGrabber), ps);
- DeleteRefToAnonymousNode(Move(mPositioningShadow), ps);
+ DeleteRefToAnonymousNode(std::move(mGrabber), ps);
+ DeleteRefToAnonymousNode(std::move(mPositioningShadow), ps);
}
nsresult
HTMLEditor::ShowGrabber(Element& aElement)
{
if (NS_WARN_IF(!IsDescendantOfEditorRoot(&aElement))) {
return NS_ERROR_UNEXPECTED;
}
@@ -380,17 +380,17 @@ HTMLEditor::GrabberClicked()
nsresult
HTMLEditor::EndMoving()
{
if (mPositioningShadow) {
nsCOMPtr<nsIPresShell> ps = GetPresShell();
NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
- DeleteRefToAnonymousNode(Move(mPositioningShadow), ps);
+ DeleteRefToAnonymousNode(std::move(mPositioningShadow), ps);
mPositioningShadow = nullptr;
}
RefPtr<EventTarget> piTarget = GetDOMEventTarget();
if (piTarget && mMouseMotionListenerP) {
piTarget->RemoveEventListener(NS_LITERAL_STRING("mousemove"),
mMouseMotionListenerP,
--- a/editor/libeditor/HTMLAnonymousNodeEditor.cpp
+++ b/editor/libeditor/HTMLAnonymousNodeEditor.cpp
@@ -225,31 +225,31 @@ HTMLEditor::CreateAnonymousElement(nsAto
// sort of ok.
newContent->SetProperty(nsGkAtoms::restylableAnonymousNode,
reinterpret_cast<void*>(true));
#endif // DEBUG
// display the element
ps->PostRecreateFramesFor(newContent);
- return Move(newContent);
+ return std::move(newContent);
}
// Removes event listener and calls DeleteRefToAnonymousNode.
void
HTMLEditor::RemoveListenerAndDeleteRef(const nsAString& aEvent,
nsIDOMEventListener* aListener,
bool aUseCapture,
ManualNACPtr aElement,
nsIPresShell* aShell)
{
if (aElement) {
aElement->RemoveEventListener(aEvent, aListener, aUseCapture);
}
- DeleteRefToAnonymousNode(Move(aElement), aShell);
+ DeleteRefToAnonymousNode(std::move(aElement), aShell);
}
// Deletes all references to an anonymous element
void
HTMLEditor::DeleteRefToAnonymousNode(ManualNACPtr aContent,
nsIPresShell* aShell)
{
// call ContentRemoved() for the anonymous content
--- a/editor/libeditor/HTMLEditRules.cpp
+++ b/editor/libeditor/HTMLEditRules.cpp
@@ -6017,17 +6017,17 @@ HTMLEditRules::CreateStyleForInsertText(
RefPtr<Element> rootElement = aDocument.GetRootElement();
if (NS_WARN_IF(!rootElement)) {
return NS_ERROR_FAILURE;
}
// process clearing any styles first
UniquePtr<PropItem> item =
- Move(HTMLEditorRef().mTypeInState->TakeClearProperty());
+ std::move(HTMLEditorRef().mTypeInState->TakeClearProperty());
{
// Transactions may set selection, but we will set selection if necessary.
AutoTransactionsConserveSelection dontChangeMySelection(&HTMLEditorRef());
while (item && node != rootElement) {
// XXX If we redesign ClearStyle(), we can use EditorDOMPoint in this
// method.
@@ -6035,24 +6035,24 @@ HTMLEditRules::CreateStyleForInsertText(
HTMLEditorRef().ClearStyle(address_of(node), &offset,
item->tag, item->attr);
if (NS_WARN_IF(!CanHandleEditAction())) {
return NS_ERROR_EDITOR_DESTROYED;
}
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
- item = Move(HTMLEditorRef().mTypeInState->TakeClearProperty());
+ item = std::move(HTMLEditorRef().mTypeInState->TakeClearProperty());
weDidSomething = true;
}
}
// then process setting any styles
int32_t relFontSize = HTMLEditorRef().mTypeInState->TakeRelativeFontSize();
- item = Move(HTMLEditorRef().mTypeInState->TakeSetProperty());
+ item = std::move(HTMLEditorRef().mTypeInState->TakeSetProperty());
if (item || relFontSize) {
// we have at least one style to add; make a new text node to insert style
// nodes above.
if (RefPtr<Text> text = node->GetAsText()) {
// if we are in a text node, split it
SplitNodeResult splitTextNodeResult =
HTMLEditorRef().SplitNodeDeepWithTransaction(
@@ -9277,17 +9277,17 @@ HTMLEditRules::JoinNearestEditableNodesW
nsresult rv =
HTMLEditorRef().JoinNodesWithTransaction(aNodeLeft, aNodeRight);
if (NS_WARN_IF(!CanHandleEditAction())) {
return NS_ERROR_EDITOR_DESTROYED;
}
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
- *aNewFirstChildOfRightNode = Move(ret);
+ *aNewFirstChildOfRightNode = std::move(ret);
return NS_OK;
}
// Remember the last left child, and first right child
nsCOMPtr<nsIContent> lastLeft =
HTMLEditorRef().GetLastEditableChild(aNodeLeft);
if (NS_WARN_IF(!lastLeft)) {
return NS_ERROR_FAILURE;
@@ -9317,17 +9317,17 @@ HTMLEditRules::JoinNearestEditableNodesW
nsresult rv =
JoinNearestEditableNodesWithTransaction(*lastLeft, *firstRight,
aNewFirstChildOfRightNode);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
return NS_OK;
}
- *aNewFirstChildOfRightNode = Move(ret);
+ *aNewFirstChildOfRightNode = std::move(ret);
return NS_OK;
}
Element*
HTMLEditRules::GetTopEnclosingMailCite(nsINode& aNode)
{
nsCOMPtr<Element> ret;
--- a/editor/libeditor/HTMLEditorObjectResizer.cpp
+++ b/editor/libeditor/HTMLEditorObjectResizer.cpp
@@ -140,17 +140,17 @@ HTMLEditor::CreateResizer(int16_t aLocat
case nsIHTMLObjectResizer::eBottomRight:
locationStr = kBottomRight;
break;
}
nsresult rv =
ret->SetAttr(kNameSpaceID_None, nsGkAtoms::anonlocation, locationStr, true);
NS_ENSURE_SUCCESS(rv, nullptr);
- return Move(ret);
+ return std::move(ret);
}
ManualNACPtr
HTMLEditor::CreateShadow(nsIContent& aParentContent,
Element& aOriginalObject)
{
// let's create an image through the element factory
RefPtr<nsAtom> name;
@@ -364,44 +364,44 @@ HTMLEditor::HideResizers()
nsCOMPtr<nsIPresShell> ps = GetPresShell();
// We allow the pres shell to be null; when it is, we presume there
// are no document observers to notify, but we still want to
// UnbindFromTree.
NS_NAMED_LITERAL_STRING(mousedown, "mousedown");
RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
- Move(mTopLeftHandle), ps);
+ std::move(mTopLeftHandle), ps);
RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
- Move(mTopHandle), ps);
+ std::move(mTopHandle), ps);
RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
- Move(mTopRightHandle), ps);
+ std::move(mTopRightHandle), ps);
RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
- Move(mLeftHandle), ps);
+ std::move(mLeftHandle), ps);
RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
- Move(mRightHandle), ps);
+ std::move(mRightHandle), ps);
RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
- Move(mBottomLeftHandle), ps);
+ std::move(mBottomLeftHandle), ps);
RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
- Move(mBottomHandle), ps);
+ std::move(mBottomHandle), ps);
RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
- Move(mBottomRightHandle), ps);
+ std::move(mBottomRightHandle), ps);
RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
- Move(mResizingShadow), ps);
+ std::move(mResizingShadow), ps);
RemoveListenerAndDeleteRef(mousedown, mEventListener, true,
- Move(mResizingInfo), ps);
+ std::move(mResizingInfo), ps);
if (mActivatedHandle) {
mActivatedHandle->UnsetAttr(kNameSpaceID_None, nsGkAtoms::_moz_activated,
true);
mActivatedHandle = nullptr;
}
// don't forget to remove the listeners !
--- a/editor/libeditor/HTMLInlineTableEditor.cpp
+++ b/editor/libeditor/HTMLInlineTableEditor.cpp
@@ -107,22 +107,22 @@ HTMLEditor::HideInlineTableEditingUI()
RemoveMouseClickListener(mAddRowAfterButton);
// get the presshell's document observer interface.
nsCOMPtr<nsIPresShell> ps = GetPresShell();
// We allow the pres shell to be null; when it is, we presume there
// are no document observers to notify, but we still want to
// UnbindFromTree.
- DeleteRefToAnonymousNode(Move(mAddColumnBeforeButton), ps);
- DeleteRefToAnonymousNode(Move(mRemoveColumnButton), ps);
- DeleteRefToAnonymousNode(Move(mAddColumnAfterButton), ps);
- DeleteRefToAnonymousNode(Move(mAddRowBeforeButton), ps);
- DeleteRefToAnonymousNode(Move(mRemoveRowButton), ps);
- DeleteRefToAnonymousNode(Move(mAddRowAfterButton), ps);
+ DeleteRefToAnonymousNode(std::move(mAddColumnBeforeButton), ps);
+ DeleteRefToAnonymousNode(std::move(mRemoveColumnButton), ps);
+ DeleteRefToAnonymousNode(std::move(mAddColumnAfterButton), ps);
+ DeleteRefToAnonymousNode(std::move(mAddRowBeforeButton), ps);
+ DeleteRefToAnonymousNode(std::move(mRemoveRowButton), ps);
+ DeleteRefToAnonymousNode(std::move(mAddRowAfterButton), ps);
return NS_OK;
}
nsresult
HTMLEditor::DoInlineTableEditingAction(const Element& aElement)
{
nsAutoString anonclass;
--- a/editor/libeditor/PlaceholderTransaction.h
+++ b/editor/libeditor/PlaceholderTransaction.h
@@ -43,19 +43,19 @@ public:
*/
static already_AddRefed<PlaceholderTransaction>
Create(EditorBase& aEditorBase,
nsAtom* aName,
Maybe<SelectionState>&& aSelState)
{
// Make sure to move aSelState into a local variable to null out the original
// Maybe<SelectionState> variable.
- Maybe<SelectionState> selState(Move(aSelState));
+ Maybe<SelectionState> selState(std::move(aSelState));
RefPtr<PlaceholderTransaction> transaction =
- new PlaceholderTransaction(aEditorBase, aName, Move(selState));
+ new PlaceholderTransaction(aEditorBase, aName, std::move(selState));
return transaction.forget();
}
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PlaceholderTransaction,
EditAggregateTransaction)
// ------------ EditAggregateTransaction -----------------------
--- a/editor/spellchecker/nsFilteredContentIterator.cpp
+++ b/editor/spellchecker/nsFilteredContentIterator.cpp
@@ -108,17 +108,17 @@ nsFilteredContentIterator::Init(const Ra
if (NS_WARN_IF(NS_FAILED(rv)) || NS_WARN_IF(!range) ||
NS_WARN_IF(!range->IsPositioned())) {
return NS_ERROR_INVALID_ARG;
}
MOZ_ASSERT(range->StartRef() == aStart);
MOZ_ASSERT(range->EndRef() == aEnd);
- mRange = Move(range);
+ mRange = std::move(range);
return InitWithRange();
}
nsresult
nsFilteredContentIterator::InitWithRange()
{
MOZ_ASSERT(mRange);
--- a/extensions/cookie/nsPermissionManager.cpp
+++ b/extensions/cookie/nsPermissionManager.cpp
@@ -3429,17 +3429,17 @@ nsPermissionManager::WhenPermissionsAvai
// content process and hasn't been requested yet. We need to create a new
// promise, and send the request to the parent (if we have not already
// done so).
promise = new GenericPromise::Private(__func__);
mPermissionKeyPromiseMap.Put(key, RefPtr<GenericPromise::Private>(promise).forget());
}
if (promise) {
- promises.AppendElement(Move(promise));
+ promises.AppendElement(std::move(promise));
}
}
// If all of our permissions are available, immediately run the runnable. This
// avoids any extra overhead during fetch interception which is performance
// sensitive.
if (promises.IsEmpty()) {
aRunnable->Run();
--- a/extensions/cookie/nsPermissionManager.h
+++ b/extensions/cookie/nsPermissionManager.h
@@ -109,18 +109,18 @@ public:
class PermissionHashKey : public nsRefPtrHashKey<PermissionKey>
{
public:
explicit PermissionHashKey(const PermissionKey* aPermissionKey)
: nsRefPtrHashKey<PermissionKey>(aPermissionKey)
{}
PermissionHashKey(PermissionHashKey&& toCopy)
- : nsRefPtrHashKey<PermissionKey>(mozilla::Move(toCopy))
- , mPermissions(mozilla::Move(toCopy.mPermissions))
+ : nsRefPtrHashKey<PermissionKey>(std::move(toCopy))
+ , mPermissions(std::move(toCopy.mPermissions))
{}
bool KeyEquals(const PermissionKey* aKey) const
{
return *aKey == *GetKey();
}
static PLDHashNumber HashKey(const PermissionKey* aKey)
--- a/extensions/spellcheck/hunspell/glue/RemoteSpellCheckEngineChild.cpp
+++ b/extensions/spellcheck/hunspell/glue/RemoteSpellCheckEngineChild.cpp
@@ -33,18 +33,18 @@ RemoteSpellcheckEngineChild::SetCurrentD
MakeUnique<MozPromiseHolder<GenericPromise>>();
if (!SendSetDictionaryFromList(
aList,
reinterpret_cast<intptr_t>(promiseHolder.get()))) {
return GenericPromise::CreateAndReject(NS_ERROR_FAILURE, __func__);
}
RefPtr<GenericPromise> result = promiseHolder->Ensure(__func__);
// promiseHolder will removed by receive message
- mResponsePromises.AppendElement(Move(promiseHolder));
- return Move(result);
+ mResponsePromises.AppendElement(std::move(promiseHolder));
+ return std::move(result);
}
mozilla::ipc::IPCResult
RemoteSpellcheckEngineChild::RecvNotifyOfCurrentDictionary(
const nsString& aDictionary,
const intptr_t& aId)
{
MozPromiseHolder<GenericPromise>* promiseHolder =
--- a/extensions/spellcheck/src/mozInlineSpellChecker.cpp
+++ b/extensions/spellcheck/src/mozInlineSpellChecker.cpp
@@ -471,32 +471,32 @@ mozInlineSpellStatus::PositionToCollapse
class mozInlineSpellResume : public Runnable
{
public:
mozInlineSpellResume(UniquePtr<mozInlineSpellStatus>&& aStatus,
uint32_t aDisabledAsyncToken)
: Runnable("mozInlineSpellResume")
, mDisabledAsyncToken(aDisabledAsyncToken)
- , mStatus(Move(aStatus))
+ , mStatus(std::move(aStatus))
{
}
nsresult Post()
{
nsCOMPtr<nsIRunnable> runnable(this);
return NS_IdleDispatchToCurrentThread(runnable.forget(), 1000);
}
NS_IMETHOD Run() override
{
// Discard the resumption if the spell checker was disabled after the
// resumption was scheduled.
if (mDisabledAsyncToken == mStatus->mSpellChecker->mDisabledAsyncToken) {
- mStatus->mSpellChecker->ResumeCheck(Move(mStatus));
+ mStatus->mSpellChecker->ResumeCheck(std::move(mStatus));
}
return NS_OK;
}
private:
uint32_t mDisabledAsyncToken;
UniquePtr<mozInlineSpellStatus> mStatus;
};
@@ -880,17 +880,17 @@ mozInlineSpellChecker::SpellCheckAfterEd
rv = status->InitForEditorChange(aEditSubAction,
aSelection.GetAnchorNode(),
aSelection.AnchorOffset(),
aPreviousSelectedNode,
aPreviousSelectedOffset,
aStartNode, aStartOffset,
aEndNode, aEndOffset);
NS_ENSURE_SUCCESS(rv, rv);
- rv = ScheduleSpellCheck(Move(status));
+ rv = ScheduleSpellCheck(std::move(status));
NS_ENSURE_SUCCESS(rv, rv);
// remember the current caret position after every change
SaveCurrentSelectionPosition();
return NS_OK;
}
// mozInlineSpellChecker::SpellCheckRange
@@ -906,17 +906,17 @@ mozInlineSpellChecker::SpellCheckRange(n
mPendingSpellCheck,
"Trying to spellcheck, but checking seems to be disabled");
return NS_ERROR_NOT_INITIALIZED;
}
auto status = MakeUnique<mozInlineSpellStatus>(this);
nsresult rv = status->InitForRange(aRange);
NS_ENSURE_SUCCESS(rv, rv);
- return ScheduleSpellCheck(Move(status));
+ return ScheduleSpellCheck(std::move(status));
}
// mozInlineSpellChecker::GetMisspelledWord
NS_IMETHODIMP
mozInlineSpellChecker::GetMisspelledWord(nsINode *aNode, int32_t aOffset,
nsRange** newword)
{
@@ -974,49 +974,49 @@ mozInlineSpellChecker::AddWordToDictiona
NS_ENSURE_TRUE(mSpellCheck, NS_ERROR_NOT_INITIALIZED);
nsresult rv = mSpellCheck->AddWordToDictionary(word);
NS_ENSURE_SUCCESS(rv, rv);
auto status = MakeUnique<mozInlineSpellStatus>(this);
rv = status->InitForSelection();
NS_ENSURE_SUCCESS(rv, rv);
- return ScheduleSpellCheck(Move(status));
+ return ScheduleSpellCheck(std::move(status));
}
// mozInlineSpellChecker::RemoveWordFromDictionary
NS_IMETHODIMP
mozInlineSpellChecker::RemoveWordFromDictionary(const nsAString &word)
{
NS_ENSURE_TRUE(mSpellCheck, NS_ERROR_NOT_INITIALIZED);
nsresult rv = mSpellCheck->RemoveWordFromDictionary(word);
NS_ENSURE_SUCCESS(rv, rv);
auto status = MakeUnique<mozInlineSpellStatus>(this);
rv = status->InitForRange(nullptr);
NS_ENSURE_SUCCESS(rv, rv);
- return ScheduleSpellCheck(Move(status));
+ return ScheduleSpellCheck(std::move(status));
}
// mozInlineSpellChecker::IgnoreWord
NS_IMETHODIMP
mozInlineSpellChecker::IgnoreWord(const nsAString &word)
{
NS_ENSURE_TRUE(mSpellCheck, NS_ERROR_NOT_INITIALIZED);
nsresult rv = mSpellCheck->IgnoreWordAllOccurrences(word);
NS_ENSURE_SUCCESS(rv, rv);
auto status = MakeUnique<mozInlineSpellStatus>(this);
rv = status->InitForSelection();
NS_ENSURE_SUCCESS(rv, rv);
- return ScheduleSpellCheck(Move(status));
+ return ScheduleSpellCheck(std::move(status));
}
// mozInlineSpellChecker::IgnoreWords
NS_IMETHODIMP
mozInlineSpellChecker::IgnoreWords(const char16_t **aWordsToIgnore,
uint32_t aCount)
{
@@ -1025,17 +1025,17 @@ mozInlineSpellChecker::IgnoreWords(const
// add each word to the ignore list and then recheck the document
for (uint32_t index = 0; index < aCount; index++)
mSpellCheck->IgnoreWordAllOccurrences(
nsDependentString(aWordsToIgnore[index]));
auto status = MakeUnique<mozInlineSpellStatus>(this);
nsresult rv = status->InitForSelection();
NS_ENSURE_SUCCESS(rv, rv);
- return ScheduleSpellCheck(Move(status));
+ return ScheduleSpellCheck(std::move(status));
}
void
mozInlineSpellChecker::DidSplitNode(nsINode* aExistingRightNode,
nsINode* aNewLeftNode)
{
if (!mIsListeningToEditSubActions) {
return;
@@ -1140,17 +1140,17 @@ mozInlineSpellChecker::SpellCheckBetween
NS_ENSURE_SUCCESS(rv, rv);
if (! range)
return NS_OK; // range is empty: nothing to do
auto status = MakeUnique<mozInlineSpellStatus>(this);
rv = status->InitForRange(range);
NS_ENSURE_SUCCESS(rv, rv);
- return ScheduleSpellCheck(Move(status));
+ return ScheduleSpellCheck(std::move(status));
}
// mozInlineSpellChecker::ShouldSpellCheckNode
//
// There are certain conditions when we don't want to spell check a node. In
// particular quotations, moz signatures, etc. This routine returns false
// for these cases.
@@ -1234,17 +1234,17 @@ mozInlineSpellChecker::ScheduleSpellChec
// Just ignore this; we're going to spell-check everything anyway
return NS_OK;
}
// Cache the value because we are going to move aStatus's ownership to
// the new created mozInlineSpellResume instance.
bool isFullSpellCheck = aStatus->IsFullSpellCheck();
RefPtr<mozInlineSpellResume> resume =
- new mozInlineSpellResume(Move(aStatus), mDisabledAsyncToken);
+ new mozInlineSpellResume(std::move(aStatus), mDisabledAsyncToken);
NS_ENSURE_TRUE(resume, NS_ERROR_OUT_OF_MEMORY);
nsresult rv = resume->Post();
if (NS_SUCCEEDED(rv)) {
if (isFullSpellCheck) {
// We're going to check everything. Suppress further spell-check attempts
// until that happens.
mFullSpellCheckScheduled = true;
@@ -1596,17 +1596,17 @@ mozInlineSpellChecker::ResumeCheck(Uniqu
bool doneChecking = true;
if (aStatus->mOp == mozInlineSpellStatus::eOpSelection)
rv = DoSpellCheckSelection(wordUtil, spellCheckSelection);
else
rv = DoSpellCheck(wordUtil, spellCheckSelection, aStatus, &doneChecking);
NS_ENSURE_SUCCESS(rv, rv);
if (! doneChecking)
- rv = ScheduleSpellCheck(Move(aStatus));
+ rv = ScheduleSpellCheck(std::move(aStatus));
return rv;
}
// mozInlineSpellChecker::IsPointInSelection
//
// Determines if a given (node,offset) point is inside the given
// selection. If so, the specific range of the selection that
// intersects is places in *aRange. (There may be multiple disjoint
@@ -1804,17 +1804,17 @@ mozInlineSpellChecker::HandleNavigationE
auto status = MakeUnique<mozInlineSpellStatus>(this);
rv = status->InitForNavigation(aForceWordSpellCheck, aNewPositionOffset,
currentAnchorNode, currentAnchorOffset,
mCurrentSelectionAnchorNode,
mCurrentSelectionOffset,
&shouldPost);
NS_ENSURE_SUCCESS(rv, rv);
if (shouldPost) {
- rv = ScheduleSpellCheck(Move(status));
+ rv = ScheduleSpellCheck(std::move(status));
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
NS_IMETHODIMP
mozInlineSpellChecker::HandleEvent(Event* aEvent)
--- a/extensions/spellcheck/src/mozPersonalDictionary.cpp
+++ b/extensions/spellcheck/src/mozPersonalDictionary.cpp
@@ -364,17 +364,17 @@ NS_IMETHODIMP mozPersonalDictionary::Sav
nsTArray<nsString> array;
nsString* elems = array.AppendElements(mDictionaryTable.Count());
for (auto iter = mDictionaryTable.Iter(); !iter.Done(); iter.Next()) {
elems->Assign(iter.Get()->GetKey());
elems++;
}
nsCOMPtr<nsIRunnable> runnable =
- new mozPersonalDictionarySave(this, theFile, mozilla::Move(array));
+ new mozPersonalDictionarySave(this, theFile, std::move(array));
res = target->Dispatch(runnable, NS_DISPATCH_NORMAL);
if (NS_WARN_IF(NS_FAILED(res))) {
return res;
}
return res;
}
NS_IMETHODIMP mozPersonalDictionary::GetWordList(nsIStringEnumerator **aWords)
--- a/gfx/2d/2D.h
+++ b/gfx/2d/2D.h
@@ -475,30 +475,30 @@ public:
*/
class ScopedMap final {
public:
explicit ScopedMap(DataSourceSurface* aSurface, MapType aType)
: mSurface(aSurface)
, mIsMapped(aSurface->Map(aType, &mMap)) {}
ScopedMap(ScopedMap&& aOther)
- : mSurface(Move(aOther.mSurface))
+ : mSurface(std::move(aOther.mSurface))
, mMap(aOther.mMap)
, mIsMapped(aOther.mIsMapped)
{
aOther.mMap.mData = nullptr;
aOther.mIsMapped = false;
}
ScopedMap& operator=(ScopedMap&& aOther)
{
if (mIsMapped) {
mSurface->Unmap();
}
- mSurface = Move(aOther.mSurface);
+ mSurface = std::move(aOther.mSurface);
mMap = aOther.mMap;
mIsMapped = aOther.mIsMapped;
aOther.mMap.mData = nullptr;
aOther.mIsMapped = false;
return *this;
}
~ScopedMap()
--- a/gfx/2d/CaptureCommandList.h
+++ b/gfx/2d/CaptureCommandList.h
@@ -19,24 +19,24 @@ namespace gfx {
class CaptureCommandList
{
public:
CaptureCommandList()
: mLastCommand(nullptr)
{}
CaptureCommandList(CaptureCommandList&& aOther)
- : mStorage(Move(aOther.mStorage)), mLastCommand(aOther.mLastCommand)
+ : mStorage(std::move(aOther.mStorage)), mLastCommand(aOther.mLastCommand)
{
aOther.mLastCommand = nullptr;
}
~CaptureCommandList();
CaptureCommandList& operator =(CaptureCommandList&& aOther) {
- mStorage = Move(aOther.mStorage);
+ mStorage = std::move(aOther.mStorage);
mLastCommand = aOther.mLastCommand;
aOther.mLastCommand = nullptr;
return *this;
}
template <typename T>
T* Append() {
size_t oldSize = mStorage.size();
--- a/gfx/2d/DrawEventRecorder.h
+++ b/gfx/2d/DrawEventRecorder.h
@@ -111,17 +111,17 @@ public:
}
return index;
}
bool WantsExternalFonts() const { return mExternalFonts; }
void TakeExternalSurfaces(std::vector<RefPtr<SourceSurface>>& aSurfaces)
{
- aSurfaces = Move(mExternalSurfaces);
+ aSurfaces = std::move(mExternalSurfaces);
}
virtual void StoreSourceSurfaceRecording(SourceSurface *aSurface,
const char *aReason);
protected:
void StoreExternalSurfaceRecording(SourceSurface* aSurface,
uint64_t aKey);
--- a/gfx/2d/DrawTargetRecording.cpp
+++ b/gfx/2d/DrawTargetRecording.cpp
@@ -84,17 +84,17 @@ public:
};
class DataSourceSurfaceRecording : public DataSourceSurface
{
public:
MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DataSourceSurfaceRecording, override)
DataSourceSurfaceRecording(UniquePtr<uint8_t[]> aData, IntSize aSize,
int32_t aStride, SurfaceFormat aFormat)
- : mData(Move(aData))
+ : mData(std::move(aData))
, mSize(aSize)
, mStride(aStride)
, mFormat(aFormat)
{
}
~DataSourceSurfaceRecording()
{
@@ -102,17 +102,17 @@ public:
static already_AddRefed<DataSourceSurface>
Init(uint8_t *aData, IntSize aSize, int32_t aStride, SurfaceFormat aFormat)
{
//XXX: do we need to ensure any alignment here?
auto data = MakeUnique<uint8_t[]>(aStride * aSize.height);
if (data) {
memcpy(data.get(), aData, aStride * aSize.height);
- RefPtr<DataSourceSurfaceRecording> surf = new DataSourceSurfaceRecording(Move(data), aSize, aStride, aFormat);
+ RefPtr<DataSourceSurfaceRecording> surf = new DataSourceSurfaceRecording(std::move(data), aSize, aStride, aFormat);
return surf.forget();
}
return nullptr;
}
virtual SurfaceType GetType() const override { return SurfaceType::RECORDING; }
virtual IntSize GetSize() const override { return mSize; }
virtual int32_t Stride() override { return mStride; }
--- a/gfx/2d/DrawingJob.cpp
+++ b/gfx/2d/DrawingJob.cpp
@@ -40,17 +40,17 @@ DrawingJobBuilder::BeginDrawingJob(DrawT
DrawingJob*
DrawingJobBuilder::EndDrawingJob(CommandBuffer* aCmdBuffer,
SyncObject* aCompletion,
WorkerThread* aPinToWorker)
{
MOZ_ASSERT(mDrawTarget);
DrawingJob* task = new DrawingJob(mDrawTarget, mOffset, mStart, aCompletion, aPinToWorker);
task->mCommandBuffer = aCmdBuffer;
- task->mCommandOffsets = Move(mCommandOffsets);
+ task->mCommandOffsets = std::move(mCommandOffsets);
mDrawTarget = nullptr;
mOffset = IntPoint();
mStart = nullptr;
return task;
}
--- a/gfx/2d/NativeFontResourceFontconfig.cpp
+++ b/gfx/2d/NativeFontResourceFontconfig.cpp
@@ -8,17 +8,17 @@
#include "ScaledFontFontconfig.h"
#include "UnscaledFontFreeType.h"
#include "Logging.h"
namespace mozilla {
namespace gfx {
NativeFontResourceFontconfig::NativeFontResourceFontconfig(UniquePtr<uint8_t[]>&& aFontData, FT_Face aFace)
- : mFontData(Move(aFontData)),
+ : mFontData(std::move(aFontData)),
mFace(aFace)
{
}
NativeFontResourceFontconfig::~NativeFontResourceFontconfig()
{
if (mFace) {
Factory::ReleaseFTFace(mFace);
@@ -43,17 +43,17 @@ NativeFontResourceFontconfig::Create(uin
return nullptr;
}
if (FT_Select_Charmap(face, FT_ENCODING_UNICODE) != FT_Err_Ok) {
Factory::ReleaseFTFace(face);
return nullptr;
}
RefPtr<NativeFontResourceFontconfig> resource =
- new NativeFontResourceFontconfig(Move(fontData), face);
+ new NativeFontResourceFontconfig(std::move(fontData), face);
return resource.forget();
}
already_AddRefed<UnscaledFont>
NativeFontResourceFontconfig::CreateUnscaledFont(uint32_t aIndex,
const uint8_t* aInstanceData, uint32_t aInstanceDataLength)
{
RefPtr<UnscaledFont> unscaledFont = new UnscaledFontFontconfig(mFace, this);
--- a/gfx/2d/Polygon.h
+++ b/gfx/2d/Polygon.h
@@ -167,17 +167,17 @@ public:
PolygonTyped() {}
explicit PolygonTyped(const nsTArray<Point4DType>& aPoints,
const Point4DType& aNormal = DefaultNormal())
: mNormal(aNormal), mPoints(aPoints) {}
explicit PolygonTyped(nsTArray<Point4DType>&& aPoints,
const Point4DType& aNormal = DefaultNormal())
- : mNormal(aNormal), mPoints(Move(aPoints)) {}
+ : mNormal(aNormal), mPoints(std::move(aPoints)) {}
explicit PolygonTyped(const std::initializer_list<Point4DType>& aPoints,
const Point4DType& aNormal = DefaultNormal())
: mNormal(aNormal), mPoints(aPoints)
{
#ifdef DEBUG
EnsurePlanarPolygon();
#endif
@@ -253,40 +253,40 @@ public:
backPoints.ClearAndRetainStorage();
frontPoints.ClearAndRetainStorage();
// Clip the polygon points using the previously calculated distances.
ClipPointsWithPlane(clippedPoints, normal, distances,
backPoints, frontPoints);
// Only use the points behind the clipping plane.
- clippedPoints = Move(backPoints);
+ clippedPoints = std::move(backPoints);
if (clippedPoints.Length() < 3) {
// The clipping created a polygon with no area.
return PolygonTyped<Units>();
}
}
- return PolygonTyped<Units>(Move(clippedPoints), mNormal);
+ return PolygonTyped<Units>(std::move(clippedPoints), mNormal);
}
/**
* Returns a new polygon containing the bounds of the given 2D rectangle.
*/
static PolygonTyped<Units> FromRect(const RectTyped<Units>& aRect)
{
nsTArray<Point4DType> points {
Point4DType(aRect.X(), aRect.Y(), 0.0f, 1.0f),
Point4DType(aRect.X(), aRect.YMost(), 0.0f, 1.0f),
Point4DType(aRect.XMost(), aRect.YMost(), 0.0f, 1.0f),
Point4DType(aRect.XMost(), aRect.Y(), 0.0f, 1.0f)
};
- return PolygonTyped<Units>(Move(points));
+ return PolygonTyped<Units>(std::move(points));
}
const Point4DType& GetNormal() const
{
return mNormal;
}
const nsTArray<Point4DType>& GetPoints() const
@@ -311,17 +311,17 @@ public:
return triangles;
}
// This fan triangulation method only works for convex polygons.
for (size_t i = 1; i < mPoints.Length() - 1; ++i) {
TriangleTyped<Units> triangle(Point(mPoints[0].x, mPoints[0].y),
Point(mPoints[i].x, mPoints[i].y),
Point(mPoints[i + 1].x, mPoints[i + 1].y));
- triangles.AppendElement(Move(triangle));
+ triangles.AppendElement(std::move(triangle));
}
return triangles;
}
void TransformToLayerSpace(const Matrix4x4Typed<Units, Units>& aTransform)
{
TransformPoints(aTransform, true);
--- a/gfx/2d/SFNTData.cpp
+++ b/gfx/2d/SFNTData.cpp
@@ -134,25 +134,25 @@ SFNTData::Create(const uint8_t *aFontDat
const BigEndianUint32* endOfOffsets = offset + numFonts;
while (offset != endOfOffsets) {
if (!sfntData->AddFont(aFontData, aDataLength, *offset)) {
return nullptr;
}
++offset;
}
- return Move(sfntData);
+ return std::move(sfntData);
}
UniquePtr<SFNTData> sfntData(new SFNTData);
if (!sfntData->AddFont(aFontData, aDataLength, 0)) {
return nullptr;
}
- return Move(sfntData);
+ return std::move(sfntData);
}
/* static */
uint64_t
SFNTData::GetUniqueKey(const uint8_t *aFontData, uint32_t aDataLength,
uint32_t aVarDataSize, const void* aVarData)
{
uint64_t hash;
@@ -194,17 +194,17 @@ bool
SFNTData::GetU16FullNames(Vector<mozilla::u16string>& aU16FullNames)
{
bool fontFound = false;
for (size_t i = 0; i < mFonts.length(); ++i) {
mozilla::u16string name;
if (mFonts[i]->GetU16FullName(name)) {
fontFound = true;
}
- if (!aU16FullNames.append(Move(name))) {
+ if (!aU16FullNames.append(std::move(name))) {
return false;
}
}
return fontFound;
}
bool
--- a/gfx/2d/SFNTNameTable.cpp
+++ b/gfx/2d/SFNTNameTable.cpp
@@ -251,17 +251,17 @@ SFNTNameTable::GetU16FullName(mozilla::u
return false;
}
mozilla::u16string styleName;
if (!ReadU16Name(StyleMatchers(), styleName)) {
return false;
}
- aU16FullName.assign(Move(familyName));
+ aU16FullName.assign(std::move(familyName));
aU16FullName.append(u" ");
aU16FullName.append(styleName);
return true;
}
bool
SFNTNameTable::ReadU16Name(const NameRecordMatchers& aMatchers,
mozilla::u16string& aU16Name)
--- a/gfx/2d/SourceSurfaceCapture.cpp
+++ b/gfx/2d/SourceSurfaceCapture.cpp
@@ -159,17 +159,17 @@ SourceSurfaceCapture::GetDataSurface()
}
void
SourceSurfaceCapture::DrawTargetWillDestroy()
{
MutexAutoLock lock(mLock);
// The source DrawTarget is going away, so we can just steal its commands.
- mCommands = Move(mOwner->mCommands);
+ mCommands = std::move(mOwner->mCommands);
mHasCommandList = true;
mOwner = nullptr;
}
void
SourceSurfaceCapture::DrawTargetWillChange()
{
MutexAutoLock lock(mLock);
--- a/gfx/2d/Triangle.h
+++ b/gfx/2d/Triangle.h
@@ -48,17 +48,17 @@ typedef TriangleTyped<UnknownUnits, Floa
template<class Units, class F = Float>
struct TexturedTriangleTyped : public TriangleTyped<Units, F>
{
explicit TexturedTriangleTyped(const TriangleTyped<Units, F>& aTriangle)
: TriangleTyped<Units, F>(aTriangle) {}
explicit TexturedTriangleTyped(TriangleTyped<Units, F>&& aTriangle)
- : TriangleTyped<Units, F>(Move(aTriangle)) {}
+ : TriangleTyped<Units, F>(std::move(aTriangle)) {}
TriangleTyped<Units, F> textureCoords;
};
typedef TexturedTriangleTyped<UnknownUnits, Float> TexturedTriangle;
} // namespace gfx
} // namespace mozilla
--- a/gfx/config/gfxVars.cpp
+++ b/gfx/config/gfxVars.cpp
@@ -51,17 +51,17 @@ gfxVars::Initialize()
// Note the GPU process is not handled here - it cannot send sync
// messages, so instead the initial data is pushed down.
if (XRE_IsContentProcess()) {
MOZ_ASSERT(gGfxVarInitUpdates, "Initial updates should be provided in content process");
if (!gGfxVarInitUpdates) {
// No provided initial updates, sync-request them from parent.
InfallibleTArray<GfxVarUpdate> initUpdates;
dom::ContentChild::GetSingleton()->SendGetGfxVars(&initUpdates);
- gGfxVarInitUpdates = new nsTArray<GfxVarUpdate>(Move(initUpdates));
+ gGfxVarInitUpdates = new nsTArray<GfxVarUpdate>(std::move(initUpdates));
}
for (const auto& varUpdate : *gGfxVarInitUpdates) {
ApplyUpdate(varUpdate);
}
gGfxVarInitUpdates = nullptr;
}
}
--- a/gfx/gl/GLContext.cpp
+++ b/gfx/gl/GLContext.cpp
@@ -2303,17 +2303,17 @@ GLContext::CreateScreenBufferImpl(const
if (!newScreen->Resize(size)) {
return false;
}
// This will rebind to 0 (Screen) if needed when
// it falls out of scope.
ScopedBindFramebuffer autoFB(this);
- mScreen = Move(newScreen);
+ mScreen = std::move(newScreen);
return true;
}
bool
GLContext::ResizeScreenBuffer(const IntSize& size)
{
if (!IsOffscreenSizeAllowed(size))
--- a/gfx/gl/GLScreenBuffer.cpp
+++ b/gfx/gl/GLScreenBuffer.cpp
@@ -43,28 +43,28 @@ UniquePtr<GLScreenBuffer>
GLScreenBuffer::Create(GLContext* gl,
const gfx::IntSize& size,
const SurfaceCaps& caps)
{
UniquePtr<GLScreenBuffer> ret;
if (caps.antialias &&
!gl->IsSupported(GLFeature::framebuffer_multisample))
{
- return Move(ret);
+ return std::move(ret);
}
layers::TextureFlags flags = layers::TextureFlags::ORIGIN_BOTTOM_LEFT;
if (!caps.premultAlpha) {
flags |= layers::TextureFlags::NON_PREMULTIPLIED;
}
UniquePtr<SurfaceFactory> factory = MakeUnique<SurfaceFactory_Basic>(gl, caps, flags);
- ret.reset( new GLScreenBuffer(gl, caps, Move(factory)) );
- return Move(ret);
+ ret.reset( new GLScreenBuffer(gl, caps, std::move(factory)) );
+ return std::move(ret);
}
/* static */ UniquePtr<SurfaceFactory>
GLScreenBuffer::CreateFactory(GLContext* gl,
const SurfaceCaps& caps,
KnowsCompositor* compositorConnection,
const layers::TextureFlags& flags)
{
@@ -128,17 +128,17 @@ GLScreenBuffer::CreateFactory(GLContext*
return factory;
}
GLScreenBuffer::GLScreenBuffer(GLContext* gl,
const SurfaceCaps& caps,
UniquePtr<SurfaceFactory> factory)
: mGL(gl)
, mCaps(caps)
- , mFactory(Move(factory))
+ , mFactory(std::move(factory))
, mNeedsBlit(true)
, mUserReadBufferMode(LOCAL_GL_BACK)
, mUserDrawBufferMode(LOCAL_GL_BACK)
, mUserDrawFB(0)
, mUserReadFB(0)
, mInternalDrawFB(0)
, mInternalReadFB(0)
#ifdef DEBUG
@@ -465,17 +465,17 @@ GLScreenBuffer::AssureBlitted()
mNeedsBlit = false;
}
void
GLScreenBuffer::Morph(UniquePtr<SurfaceFactory> newFactory)
{
MOZ_RELEASE_ASSERT(newFactory, "newFactory must not be null");
- mFactory = Move(newFactory);
+ mFactory = std::move(newFactory);
}
bool
GLScreenBuffer::Attach(SharedSurface* surf, const gfx::IntSize& size)
{
ScopedBindFramebuffer autoFB(mGL);
const bool readNeedsUnlock = (mRead && SharedSurf());
@@ -514,19 +514,19 @@ GLScreenBuffer::Attach(SharedSurface* su
surf->UnlockProd();
if (readNeedsUnlock) {
SharedSurf()->LockProd();
}
return false;
}
if (draw)
- mDraw = Move(draw);
+ mDraw = std::move(draw);
- mRead = Move(read);
+ mRead = std::move(read);
}
// Check that we're all set up.
MOZ_ASSERT(SharedSurf() == surf);
// Update the ReadBuffer mode.
if (mGL->IsSupported(gl::GLFeature::read_buffer)) {
BindFB(0);
@@ -858,17 +858,17 @@ DrawBuffer::Create(GLContext* const gl,
UniquePtr<DrawBuffer> ret( new DrawBuffer(gl, size, samples, fb, colorMSRB,
depthRB, stencilRB) );
GLenum err = localError.GetError();
MOZ_ASSERT_IF(err != LOCAL_GL_NO_ERROR, err == LOCAL_GL_OUT_OF_MEMORY);
if (err || !gl->IsFramebufferComplete(fb))
return false;
- *out_buffer = Move(ret);
+ *out_buffer = std::move(ret);
return true;
}
DrawBuffer::~DrawBuffer()
{
if (!mGL->MakeCurrent())
return;
@@ -948,17 +948,17 @@ ReadBuffer::Create(GLContext* gl,
const bool isComplete = gl->IsFramebufferComplete(fb);
if (needsAcquire) {
surf->ProducerReadRelease();
}
if (!isComplete)
return nullptr;
- return Move(ret);
+ return std::move(ret);
}
ReadBuffer::~ReadBuffer()
{
if (!mGL->MakeCurrent())
return;
GLuint fb = mFB;
--- a/gfx/gl/MozFramebuffer.cpp
+++ b/gfx/gl/MozFramebuffer.cpp
@@ -129,17 +129,17 @@ MozFramebuffer::CreateWith(GLContext* co
}
const auto status = gl->fCheckFramebufferStatus(LOCAL_GL_FRAMEBUFFER);
if (status != LOCAL_GL_FRAMEBUFFER_COMPLETE) {
MOZ_ASSERT(false);
return nullptr;
}
- return Move(mozFB);
+ return std::move(mozFB);
}
////////////////////
MozFramebuffer::MozFramebuffer(GLContext* const gl, const gfx::IntSize& size,
const uint32_t samples, const bool depthStencil,
const GLenum colorTarget, const GLuint colorName)
: mWeakGL(gl)
--- a/gfx/gl/SharedSurface.cpp
+++ b/gfx/gl/SharedSurface.cpp
@@ -327,22 +327,22 @@ SurfaceFactory::NewTexClient(const gfx::
if (cur->Surf()->mSize == size) {
cur->Surf()->WaitForBufferOwnership();
return cur.forget();
}
StopRecycling(cur);
}
- UniquePtr<SharedSurface> surf = Move(CreateShared(size));
+ UniquePtr<SharedSurface> surf = std::move(CreateShared(size));
if (!surf)
return nullptr;
RefPtr<layers::SharedSurfaceTextureClient> ret;
- ret = layers::SharedSurfaceTextureClient::Create(Move(surf), this, mAllocator, mFlags);
+ ret = layers::SharedSurfaceTextureClient::Create(std::move(surf), this, mAllocator, mFlags);
StartRecycling(ret);
return ret.forget();
}
void
SurfaceFactory::StartRecycling(layers::SharedSurfaceTextureClient* tc)
--- a/gfx/gl/SharedSurfaceANGLE.cpp
+++ b/gfx/gl/SharedSurfaceANGLE.cpp
@@ -72,17 +72,17 @@ SharedSurface_ANGLEShareHandle::Create(G
pbuffer,
LOCAL_EGL_DXGI_KEYED_MUTEX_ANGLE,
&opaqueKeyedMutex);
RefPtr<IDXGIKeyedMutex> keyedMutex = static_cast<IDXGIKeyedMutex*>(opaqueKeyedMutex);
typedef SharedSurface_ANGLEShareHandle ptrT;
UniquePtr<ptrT> ret( new ptrT(gl, egl, size, hasAlpha, pbuffer, shareHandle,
keyedMutex) );
- return Move(ret);
+ return std::move(ret);
}
EGLDisplay
SharedSurface_ANGLEShareHandle::Display()
{
return mEGL->Display();
}
@@ -332,17 +332,17 @@ SurfaceFactory_ANGLEShareHandle::Create(
auto ext = GLLibraryEGL::ANGLE_surface_d3d_texture_2d_share_handle;
if (!egl->IsExtensionSupported(ext))
return nullptr;
EGLConfig config = GLContextEGL::Cast(gl)->mConfig;
typedef SurfaceFactory_ANGLEShareHandle ptrT;
UniquePtr<ptrT> ret( new ptrT(gl, caps, allocator, flags, egl, config) );
- return Move(ret);
+ return std::move(ret);
}
SurfaceFactory_ANGLEShareHandle::SurfaceFactory_ANGLEShareHandle(GLContext* gl,
const SurfaceCaps& caps,
const RefPtr<layers::LayersIPCChannel>& allocator,
const layers::TextureFlags& flags,
GLLibraryEGL* egl,
EGLConfig config)
--- a/gfx/gl/SharedSurfaceD3D11Interop.cpp
+++ b/gfx/gl/SharedSurfaceD3D11Interop.cpp
@@ -402,17 +402,17 @@ SharedSurface_D3D11Interop::Create(DXInt
}
}
////
typedef SharedSurface_D3D11Interop ptrT;
UniquePtr<ptrT> ret ( new ptrT(gl, size, hasAlpha, prodTex, interopFB, interopRB,
interop, lockHandle, texD3D, dxgiHandle) );
- return Move(ret);
+ return std::move(ret);
}
SharedSurface_D3D11Interop::SharedSurface_D3D11Interop(GLContext* gl,
const gfx::IntSize& size,
bool hasAlpha, GLuint prodTex,
GLuint interopFB, GLuint interopRB,
DXInterop2Device* interop,
HANDLE lockHandle,
@@ -511,17 +511,17 @@ SurfaceFactory_D3D11Interop::Create(GLCo
const RefPtr<DXInterop2Device> interop = DXInterop2Device::Open(wgl, gl);
if (!interop) {
NS_WARNING("Failed to open D3D device for use by WGL.");
return nullptr;
}
typedef SurfaceFactory_D3D11Interop ptrT;
UniquePtr<ptrT> ret(new ptrT(gl, caps, allocator, flags, interop));
- return Move(ret);
+ return std::move(ret);
}
SurfaceFactory_D3D11Interop::SurfaceFactory_D3D11Interop(GLContext* gl,
const SurfaceCaps& caps,
layers::LayersIPCChannel* allocator,
const layers::TextureFlags& flags,
DXInterop2Device* interop)
: SurfaceFactory(SharedSurfaceType::DXGLInterop2, gl, caps, allocator, flags)
--- a/gfx/gl/SharedSurfaceEGL.cpp
+++ b/gfx/gl/SharedSurfaceEGL.cpp
@@ -25,37 +25,37 @@ SharedSurface_EGLImage::Create(GLContext
{
GLLibraryEGL* egl = &sEGLLibrary;
MOZ_ASSERT(egl);
MOZ_ASSERT(context);
UniquePtr<SharedSurface_EGLImage> ret;
if (!HasExtensions(egl, prodGL)) {
- return Move(ret);
+ return std::move(ret);
}
MOZ_ALWAYS_TRUE(prodGL->MakeCurrent());
GLuint prodTex = CreateTextureForOffscreen(prodGL, formats, size);
if (!prodTex) {
- return Move(ret);
+ return std::move(ret);
}
EGLClientBuffer buffer = reinterpret_cast<EGLClientBuffer>(uintptr_t(prodTex));
EGLImage image = egl->fCreateImage(egl->Display(), context,
LOCAL_EGL_GL_TEXTURE_2D, buffer,
nullptr);
if (!image) {
prodGL->fDeleteTextures(1, &prodTex);
- return Move(ret);
+ return std::move(ret);
}
ret.reset( new SharedSurface_EGLImage(prodGL, egl, size, hasAlpha,
formats, prodTex, image) );
- return Move(ret);
+ return std::move(ret);
}
bool
SharedSurface_EGLImage::HasExtensions(GLLibraryEGL* egl, GLContext* gl)
{
return egl->HasKHRImageBase() &&
egl->IsExtensionSupported(GLLibraryEGL::KHR_gl_texture_2D_image) &&
(gl->IsExtensionSupported(GLContext::OES_EGL_image_external) ||
@@ -172,17 +172,17 @@ SurfaceFactory_EGLImage::Create(GLContex
typedef SurfaceFactory_EGLImage ptrT;
UniquePtr<ptrT> ret;
GLLibraryEGL* egl = &sEGLLibrary;
if (SharedSurface_EGLImage::HasExtensions(egl, prodGL)) {
ret.reset( new ptrT(prodGL, caps, allocator, flags, context) );
}
- return Move(ret);
+ return std::move(ret);
}
////////////////////////////////////////////////////////////////////////
#ifdef MOZ_WIDGET_ANDROID
/*static*/ UniquePtr<SharedSurface_SurfaceTexture>
SharedSurface_SurfaceTexture::Create(GLContext* prodGL,
@@ -195,22 +195,22 @@ SharedSurface_SurfaceTexture::Create(GLC
UniquePtr<SharedSurface_SurfaceTexture> ret;
AndroidNativeWindow window(surface);
GLContextEGL* egl = GLContextEGL::Cast(prodGL);
MOZ_ASSERT(egl);
EGLSurface eglSurface = egl->CreateCompatibleSurface(window.NativeWindow());
if (!eglSurface) {
- return Move(ret);
+ return std::move(ret);
}
ret.reset(new SharedSurface_SurfaceTexture(prodGL, size, hasAlpha,
formats, surface, eglSurface));
- return Move(ret);
+ return std::move(ret);
}
SharedSurface_SurfaceTexture::SharedSurface_SurfaceTexture(GLContext* gl,
const gfx::IntSize& size,
bool hasAlpha,
const GLFormats& formats,
java::GeckoSurface::Param surface,
EGLSurface eglSurface)
@@ -287,17 +287,17 @@ SharedSurface_SurfaceTexture::ToSurfaceD
/*static*/ UniquePtr<SurfaceFactory_SurfaceTexture>
SurfaceFactory_SurfaceTexture::Create(GLContext* prodGL, const SurfaceCaps& caps,
const RefPtr<layers::LayersIPCChannel>& allocator,
const layers::TextureFlags& flags)
{
UniquePtr<SurfaceFactory_SurfaceTexture> ret(
new SurfaceFactory_SurfaceTexture(prodGL, caps, allocator, flags));
- return Move(ret);
+ return std::move(ret);
}
UniquePtr<SharedSurface>
SurfaceFactory_SurfaceTexture::CreateShared(const gfx::IntSize& size)
{
bool hasAlpha = mReadCaps.alpha;
jni::Object::LocalRef surface = java::SurfaceAllocator::AcquireSurface(size.width, size.height, true);
--- a/gfx/gl/SharedSurfaceGL.cpp
+++ b/gfx/gl/SharedSurfaceGL.cpp
@@ -28,35 +28,35 @@ SharedSurface_Basic::Create(GLContext* g
GLContext::LocalErrorScope localError(*gl);
GLuint tex = CreateTextureForOffscreen(gl, formats, size);
GLenum err = localError.GetError();
MOZ_ASSERT_IF(err != LOCAL_GL_NO_ERROR, err == LOCAL_GL_OUT_OF_MEMORY);
if (err) {
gl->fDeleteTextures(1, &tex);
- return Move(ret);
+ return std::move(ret);
}
bool ownsTex = true;
ret.reset( new SharedSurface_Basic(gl, size, hasAlpha, tex, ownsTex) );
- return Move(ret);
+ return std::move(ret);
}
/*static*/ UniquePtr<SharedSurface_Basic>
SharedSurface_Basic::Wrap(GLContext* gl,
const IntSize& size,
bool hasAlpha,
GLuint tex)
{
bool ownsTex = false;
UniquePtr<SharedSurface_Basic> ret( new SharedSurface_Basic(gl, size, hasAlpha, tex,
ownsTex) );
- return Move(ret);
+ return std::move(ret);
}
SharedSurface_Basic::SharedSurface_Basic(GLContext* gl,
const IntSize& size,
bool hasAlpha,
GLuint tex,
bool ownsTex)
: SharedSurface(SharedSurfaceType::Basic,
@@ -121,22 +121,22 @@ SharedSurface_GLTexture::Create(GLContex
GLContext::LocalErrorScope localError(*prodGL);
GLuint tex = CreateTextureForOffscreen(prodGL, formats, size);
GLenum err = localError.GetError();
MOZ_ASSERT_IF(err, err == LOCAL_GL_OUT_OF_MEMORY);
if (err) {
prodGL->fDeleteTextures(1, &tex);
- return Move(ret);
+ return std::move(ret);
}
ret.reset(new SharedSurface_GLTexture(prodGL, size,
hasAlpha, tex));
- return Move(ret);
+ return std::move(ret);
}
SharedSurface_GLTexture::~SharedSurface_GLTexture()
{
if (!mGL->MakeCurrent())
return;
if (mTex) {
--- a/gfx/gl/SharedSurfaceGLX.cpp
+++ b/gfx/gl/SharedSurfaceGLX.cpp
@@ -32,17 +32,17 @@ SharedSurface_GLXDrawable::Create(GLCont
Screen* screen = XDefaultScreenOfDisplay(display);
Visual* visual = gfxXlibSurface::FindVisual(screen, gfx::SurfaceFormat::A8R8G8B8_UINT32);
RefPtr<gfxXlibSurface> surf = gfxXlibSurface::Create(screen, visual, size);
if (!deallocateClient)
surf->ReleasePixmap();
ret.reset(new SharedSurface_GLXDrawable(prodGL, size, inSameProcess, surf));
- return Move(ret);
+ return std::move(ret);
}
SharedSurface_GLXDrawable::SharedSurface_GLXDrawable(GLContext* gl,
const gfx::IntSize& size,
bool inSameProcess,
const RefPtr<gfxXlibSurface>& xlibSurface)
: SharedSurface(SharedSurfaceType::GLXDrawable,
@@ -124,17 +124,17 @@ SurfaceFactory_GLXDrawable::Create(GLCon
const RefPtr<layers::LayersIPCChannel>& allocator,
const layers::TextureFlags& flags)
{
MOZ_ASSERT(caps.alpha, "GLX surfaces require an alpha channel!");
typedef SurfaceFactory_GLXDrawable ptrT;
UniquePtr<ptrT> ret(new ptrT(prodGL, caps, allocator,
flags & ~layers::TextureFlags::ORIGIN_BOTTOM_LEFT));
- return Move(ret);
+ return std::move(ret);
}
UniquePtr<SharedSurface>
SurfaceFactory_GLXDrawable::CreateShared(const gfx::IntSize& size)
{
bool deallocateClient = !!(mFlags & layers::TextureFlags::DEALLOCATE_CLIENT);
return SharedSurface_GLXDrawable::Create(mGL, mCaps, size, deallocateClient,
mAllocator->IsSameProcess());
--- a/gfx/gl/SharedSurfaceIO.cpp
+++ b/gfx/gl/SharedSurfaceIO.cpp
@@ -21,17 +21,17 @@ SharedSurface_IOSurface::Create(const Re
{
MOZ_ASSERT(ioSurf);
MOZ_ASSERT(gl);
auto size = gfx::IntSize::Truncate(ioSurf->GetWidth(), ioSurf->GetHeight());
typedef SharedSurface_IOSurface ptrT;
UniquePtr<ptrT> ret( new ptrT(ioSurf, gl, size, hasAlpha) );
- return Move(ret);
+ return std::move(ret);
}
void
SharedSurface_IOSurface::ProducerReleaseImpl()
{
mGL->MakeCurrent();
mGL->fFlush();
}
@@ -214,17 +214,17 @@ SurfaceFactory_IOSurface::Create(GLConte
const RefPtr<layers::LayersIPCChannel>& allocator,
const layers::TextureFlags& flags)
{
auto maxDims = gfx::IntSize::Truncate(MacIOSurface::GetMaxWidth(),
MacIOSurface::GetMaxHeight());
typedef SurfaceFactory_IOSurface ptrT;
UniquePtr<ptrT> ret( new ptrT(gl, caps, allocator, flags, maxDims) );
- return Move(ret);
+ return std::move(ret);
}
UniquePtr<SharedSurface>
SurfaceFactory_IOSurface::CreateShared(const gfx::IntSize& size)
{
if (size.width > mMaxDims.width ||
size.height > mMaxDims.height)
{
--- a/gfx/ipc/GPUChild.cpp
+++ b/gfx/ipc/GPUChild.cpp
@@ -318,28 +318,28 @@ GPUChild::RecvBHRThreadHang(const HangDe
return IPC_OK();
}
class DeferredDeleteGPUChild : public Runnable
{
public:
explicit DeferredDeleteGPUChild(UniquePtr<GPUChild>&& aChild)
: Runnable("gfx::DeferredDeleteGPUChild")
- , mChild(Move(aChild))
+ , mChild(std::move(aChild))
{
}
NS_IMETHODIMP Run() override {
return NS_OK;
}
private:
UniquePtr<GPUChild> mChild;
};
/* static */ void
GPUChild::Destroy(UniquePtr<GPUChild>&& aChild)
{
- NS_DispatchToMainThread(new DeferredDeleteGPUChild(Move(aChild)));
+ NS_DispatchToMainThread(new DeferredDeleteGPUChild(std::move(aChild)));
}
} // namespace gfx
} // namespace mozilla
--- a/gfx/ipc/GPUParent.cpp
+++ b/gfx/ipc/GPUParent.cpp
@@ -275,53 +275,53 @@ GPUParent::RecvInit(nsTArray<GfxPrefSett
Telemetry::AccumulateTimeDelta(Telemetry::GPU_PROCESS_INITIALIZATION_TIME_MS, mLaunchTime);
return IPC_OK();
}
mozilla::ipc::IPCResult
GPUParent::RecvInitCompositorManager(Endpoint<PCompositorManagerParent>&& aEndpoint)
{
- CompositorManagerParent::Create(Move(aEndpoint));
+ CompositorManagerParent::Create(std::move(aEndpoint));
return IPC_OK();
}
mozilla::ipc::IPCResult
GPUParent::RecvInitVsyncBridge(Endpoint<PVsyncBridgeParent>&& aVsyncEndpoint)
{
- mVsyncBridge = VsyncBridgeParent::Start(Move(aVsyncEndpoint));
+ mVsyncBridge = VsyncBridgeParent::Start(std::move(aVsyncEndpoint));
return IPC_OK();
}
mozilla::ipc::IPCResult
GPUParent::RecvInitImageBridge(Endpoint<PImageBridgeParent>&& aEndpoint)
{
- ImageBridgeParent::CreateForGPUProcess(Move(aEndpoint));
+ ImageBridgeParent::CreateForGPUProcess(std::move(aEndpoint));
return IPC_OK();
}
mozilla::ipc::IPCResult
GPUParent::RecvInitVRManager(Endpoint<PVRManagerParent>&& aEndpoint)
{
- VRManagerParent::CreateForGPUProcess(Move(aEndpoint));
+ VRManagerParent::CreateForGPUProcess(std::move(aEndpoint));
return IPC_OK();
}
mozilla::ipc::IPCResult
GPUParent::RecvInitUiCompositorController(const LayersId& aRootLayerTreeId, Endpoint<PUiCompositorControllerParent>&& aEndpoint)
{
- UiCompositorControllerParent::Start(aRootLayerTreeId, Move(aEndpoint));
+ UiCompositorControllerParent::Start(aRootLayerTreeId, std::move(aEndpoint));
return IPC_OK();
}
mozilla::ipc::IPCResult
GPUParent::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
GPUParent::RecvUpdatePref(const GfxPrefSetting& setting)
{
gfxPrefs::Pref* pref = gfxPrefs::all()[setting.index()];
@@ -386,42 +386,42 @@ GPUParent::RecvSimulateDeviceReset(GPUDe
#endif
RecvGetDeviceStatus(aOut);
return IPC_OK();
}
mozilla::ipc::IPCResult
GPUParent::RecvNewContentCompositorManager(Endpoint<PCompositorManagerParent>&& aEndpoint)
{
- CompositorManagerParent::Create(Move(aEndpoint));
+ CompositorManagerParent::Create(std::move(aEndpoint));
return IPC_OK();
}
mozilla::ipc::IPCResult
GPUParent::RecvNewContentImageBridge(Endpoint<PImageBridgeParent>&& aEndpoint)
{
- if (!ImageBridgeParent::CreateForContent(Move(aEndpoint))) {
+ if (!ImageBridgeParent::CreateForContent(std::move(aEndpoint))) {
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();
}
mozilla::ipc::IPCResult
GPUParent::RecvNewContentVRManager(Endpoint<PVRManagerParent>&& aEndpoint)
{
- if (!VRManagerParent::CreateForContent(Move(aEndpoint))) {
+ if (!VRManagerParent::CreateForContent(std::move(aEndpoint))) {
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();
}
mozilla::ipc::IPCResult
GPUParent::RecvNewContentVideoDecoderManager(Endpoint<PVideoDecoderManagerParent>&& aEndpoint)
{
- if (!dom::VideoDecoderManagerParent::CreateForContent(Move(aEndpoint))) {
+ if (!dom::VideoDecoderManagerParent::CreateForContent(std::move(aEndpoint))) {
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();
}
mozilla::ipc::IPCResult
GPUParent::RecvAddLayerTreeIdMapping(const LayerTreeIdMapping& aMapping)
{
--- a/gfx/ipc/GPUProcessHost.cpp
+++ b/gfx/ipc/GPUProcessHost.cpp
@@ -195,17 +195,17 @@ GPUProcessHost::OnChannelClosed()
if (!mShutdownRequested && mListener) {
// This is an unclean shutdown. Notify our listener that we're going away.
mListener->OnProcessUnexpectedShutdown(this);
} else {
DestroyProcess();
}
// Release the actor.
- GPUChild::Destroy(Move(mGPUChild));
+ GPUChild::Destroy(std::move(mGPUChild));
MOZ_ASSERT(!mGPUChild);
}
void
GPUProcessHost::KillHard(const char* aReason)
{
ProcessHandle handle = GetChildProcessHandle();
if (!base::KillProcess(handle, base::PROCESS_END_KILLED_BY_USER, false)) {
--- a/gfx/ipc/GPUProcessManager.cpp
+++ b/gfx/ipc/GPUProcessManager.cpp
@@ -254,18 +254,18 @@ GPUProcessManager::EnsureCompositorManag
base::GetCurrentProcId(),
&parentPipe,
&childPipe);
if (NS_FAILED(rv)) {
DisableGPUProcess("Failed to create PCompositorManager endpoints");
return;
}
- mGPUChild->SendInitCompositorManager(Move(parentPipe));
- CompositorManagerChild::Init(Move(childPipe), AllocateNamespace(),
+ mGPUChild->SendInitCompositorManager(std::move(parentPipe));
+ CompositorManagerChild::Init(std::move(childPipe), AllocateNamespace(),
mProcessToken);
}
void
GPUProcessManager::EnsureImageBridgeChild()
{
if (ImageBridgeChild::GetSingleton()) {
return;
@@ -283,18 +283,18 @@ GPUProcessManager::EnsureImageBridgeChil
base::GetCurrentProcId(),
&parentPipe,
&childPipe);
if (NS_FAILED(rv)) {
DisableGPUProcess("Failed to create PImageBridge endpoints");
return;
}
- mGPUChild->SendInitImageBridge(Move(parentPipe));
- ImageBridgeChild::InitWithGPUProcess(Move(childPipe), AllocateNamespace());
+ mGPUChild->SendInitImageBridge(std::move(parentPipe));
+ ImageBridgeChild::InitWithGPUProcess(std::move(childPipe), AllocateNamespace());
}
void
GPUProcessManager::EnsureVRManager()
{
if (VRManagerChild::IsCreated()) {
return;
}
@@ -311,18 +311,18 @@ GPUProcessManager::EnsureVRManager()
base::GetCurrentProcId(),
&parentPipe,
&childPipe);
if (NS_FAILED(rv)) {
DisableGPUProcess("Failed to create PVRManager endpoints");
return;
}
- mGPUChild->SendInitVRManager(Move(parentPipe));
- VRManagerChild::InitWithGPUProcess(Move(childPipe));
+ mGPUChild->SendInitVRManager(std::move(parentPipe));
+ VRManagerChild::InitWithGPUProcess(std::move(childPipe));
}
#if defined(MOZ_WIDGET_ANDROID)
already_AddRefed<UiCompositorControllerChild>
GPUProcessManager::CreateUiCompositorController(nsBaseWidget* aWidget, const LayersId aId)
{
RefPtr<UiCompositorControllerChild> result;
@@ -336,18 +336,18 @@ GPUProcessManager::CreateUiCompositorCon
base::GetCurrentProcId(),
&parentPipe,
&childPipe);
if (NS_FAILED(rv)) {
DisableGPUProcess("Failed to create PUiCompositorController endpoints");
return nullptr;
}
- mGPUChild->SendInitUiCompositorController(aId, Move(parentPipe));
- result = UiCompositorControllerChild::CreateForGPUProcess(mProcessToken, Move(childPipe));
+ mGPUChild->SendInitUiCompositorController(aId, std::move(parentPipe));
+ result = UiCompositorControllerChild::CreateForGPUProcess(mProcessToken, std::move(childPipe));
}
if (result) {
result->SetBaseWidget(aWidget);
}
return result.forget();
}
#endif // defined(MOZ_WIDGET_ANDROID)
@@ -371,18 +371,18 @@ GPUProcessManager::OnProcessLaunchComple
base::GetCurrentProcId(),
&vsyncParent,
&vsyncChild);
if (NS_FAILED(rv)) {
DisableGPUProcess("Failed to create PVsyncBridge endpoints");
return;
}
- mVsyncBridge = VsyncBridgeChild::Create(mVsyncIOThread, mProcessToken, Move(vsyncChild));
- mGPUChild->SendInitVsyncBridge(Move(vsyncParent));
+ mVsyncBridge = VsyncBridgeChild::Create(mVsyncIOThread, mProcessToken, std::move(vsyncChild));
+ mGPUChild->SendInitVsyncBridge(std::move(vsyncParent));
CrashReporter::AnnotateCrashReport(
NS_LITERAL_CSTRING("GPUProcessStatus"),
NS_LITERAL_CSTRING("Running"));
CrashReporter::AnnotateCrashReport(
NS_LITERAL_CSTRING("GPUProcessLaunchCount"),
nsPrintfCString("%d", mNumProcessAttempts));
@@ -891,22 +891,22 @@ GPUProcessManager::CreateContentComposit
&parentPipe,
&childPipe);
if (NS_FAILED(rv)) {
gfxCriticalNote << "Could not create content compositor manager: " << hexa(int(rv));
return false;
}
if (mGPUChild) {
- mGPUChild->SendNewContentCompositorManager(Move(parentPipe));
+ mGPUChild->SendNewContentCompositorManager(std::move(parentPipe));
} else {
- CompositorManagerParent::Create(Move(parentPipe));
+ CompositorManagerParent::Create(std::move(parentPipe));
}
- *aOutEndpoint = Move(childPipe);
+ *aOutEndpoint = std::move(childPipe);
return true;
}
bool
GPUProcessManager::CreateContentImageBridge(base::ProcessId aOtherProcess,
ipc::Endpoint<PImageBridgeChild>* aOutEndpoint)
{
EnsureImageBridgeChild();
@@ -923,24 +923,24 @@ GPUProcessManager::CreateContentImageBri
&parentPipe,
&childPipe);
if (NS_FAILED(rv)) {
gfxCriticalNote << "Could not create content compositor bridge: " << hexa(int(rv));
return false;
}
if (mGPUChild) {
- mGPUChild->SendNewContentImageBridge(Move(parentPipe));
+ mGPUChild->SendNewContentImageBridge(std::move(parentPipe));
} else {
- if (!ImageBridgeParent::CreateForContent(Move(parentPipe))) {
+ if (!ImageBridgeParent::CreateForContent(std::move(parentPipe))) {
return false;
}
}
- *aOutEndpoint = Move(childPipe);
+ *aOutEndpoint = std::move(childPipe);
return true;
}
base::ProcessId
GPUProcessManager::GPUProcessPid()
{
base::ProcessId gpuPid = mGPUChild
? mGPUChild->OtherPid()
@@ -966,24 +966,24 @@ GPUProcessManager::CreateContentVRManage
&parentPipe,
&childPipe);
if (NS_FAILED(rv)) {
gfxCriticalNote << "Could not create content compositor bridge: " << hexa(int(rv));
return false;
}
if (mGPUChild) {
- mGPUChild->SendNewContentVRManager(Move(parentPipe));
+ mGPUChild->SendNewContentVRManager(std::move(parentPipe));
} else {
- if (!VRManagerParent::CreateForContent(Move(parentPipe))) {
+ if (!VRManagerParent::CreateForContent(std::move(parentPipe))) {
return false;
}
}
- *aOutEndpoint = Move(childPipe);
+ *aOutEndpoint = std::move(childPipe);
return true;
}
void
GPUProcessManager::CreateContentVideoDecoderManager(base::ProcessId aOtherProcess,
ipc::Endpoint<dom::PVideoDecoderManagerChild>* aOutEndpoint)
{
if (!EnsureGPUReady() ||
@@ -1000,19 +1000,19 @@ GPUProcessManager::CreateContentVideoDec
aOtherProcess,
&parentPipe,
&childPipe);
if (NS_FAILED(rv)) {
gfxCriticalNote << "Could not create content video decoder: " << hexa(int(rv));
return;
}
- mGPUChild->SendNewContentVideoDecoderManager(Move(parentPipe));
+ mGPUChild->SendNewContentVideoDecoderManager(std::move(parentPipe));
- *aOutEndpoint = Move(childPipe);
+ *aOutEndpoint = std::move(childPipe);
}
void
GPUProcessManager::MapLayerTreeId(LayersId aLayersId, base::ProcessId aOwningId)
{
LayerTreeOwnerTracker::Get()->Map(aLayersId, aOwningId);
if (EnsureGPUReady()) {
--- a/gfx/ipc/VsyncBridgeChild.cpp
+++ b/gfx/ipc/VsyncBridgeChild.cpp
@@ -27,17 +27,17 @@ VsyncBridgeChild::Create(RefPtr<VsyncIOT
Endpoint<PVsyncBridgeChild>&& aEndpoint)
{
RefPtr<VsyncBridgeChild> child = new VsyncBridgeChild(aThread, aProcessToken);
RefPtr<nsIRunnable> task = NewRunnableMethod<Endpoint<PVsyncBridgeChild>&&>(
"gfx::VsyncBridgeChild::Open",
child,
&VsyncBridgeChild::Open,
- Move(aEndpoint));
+ std::move(aEndpoint));
aThread->GetThread()->Dispatch(task.forget(), nsIThread::DISPATCH_NORMAL);
return child;
}
void
VsyncBridgeChild::Open(Endpoint<PVsyncBridgeChild>&& aEndpoint)
{
--- a/gfx/ipc/VsyncBridgeParent.cpp
+++ b/gfx/ipc/VsyncBridgeParent.cpp
@@ -13,17 +13,17 @@ RefPtr<VsyncBridgeParent>
VsyncBridgeParent::Start(Endpoint<PVsyncBridgeParent>&& aEndpoint)
{
RefPtr<VsyncBridgeParent> parent = new VsyncBridgeParent();
RefPtr<Runnable> task = NewRunnableMethod<Endpoint<PVsyncBridgeParent>&&>(
"gfx::VsyncBridgeParent::Open",
parent,
&VsyncBridgeParent::Open,
- Move(aEndpoint));
+ std::move(aEndpoint));
CompositorThreadHolder::Loop()->PostTask(task.forget());
return parent;
}
VsyncBridgeParent::VsyncBridgeParent()
: mOpen(false)
{
--- a/gfx/layers/AnimationHelper.cpp
+++ b/gfx/layers/AnimationHelper.cpp
@@ -89,36 +89,36 @@ void
CompositorAnimationStorage::SetAnimatedValue(uint64_t aId,
gfx::Matrix4x4&& aTransformInDevSpace,
gfx::Matrix4x4&& aFrameTransform,
const TransformData& aData)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
auto count = mAnimatedValues.Count();
AnimatedValue* value = mAnimatedValues.LookupOrAdd(aId,
- Move(aTransformInDevSpace),
- Move(aFrameTransform),
+ std::move(aTransformInDevSpace),
+ std::move(aFrameTransform),
aData);
if (count == mAnimatedValues.Count()) {
MOZ_ASSERT(value->mType == AnimatedValue::TRANSFORM);
- value->mTransform.mTransformInDevSpace = Move(aTransformInDevSpace);
- value->mTransform.mFrameTransform = Move(aFrameTransform);
+ value->mTransform.mTransformInDevSpace = std::move(aTransformInDevSpace);
+ value->mTransform.mFrameTransform = std::move(aFrameTransform);
value->mTransform.mData = aData;
}
}
void
CompositorAnimationStorage::SetAnimatedValue(uint64_t aId,
gfx::Matrix4x4&& aTransformInDevSpace)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
const TransformData dontCare = {};
SetAnimatedValue(aId,
- Move(aTransformInDevSpace),
- Move(gfx::Matrix4x4()),
+ std::move(aTransformInDevSpace),
+ std::move(gfx::Matrix4x4()),
dontCare);
}
void
CompositorAnimationStorage::SetAnimatedValue(uint64_t aId,
const float& aOpacity)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
@@ -576,17 +576,17 @@ AnimationHelper::SetAnimations(
data->mTiming = TimingParams {
animation.duration(),
animation.delay(),
animation.endDelay(),
animation.iterations(),
animation.iterationStart(),
static_cast<dom::PlaybackDirection>(animation.direction()),
static_cast<dom::FillMode>(animation.fillMode()),
- Move(AnimationUtils::TimingFunctionToComputedTimingFunction(
+ std::move(AnimationUtils::TimingFunctionToComputedTimingFunction(
animation.easingFunction()))
};
InfallibleTArray<Maybe<ComputedTimingFunction>>& functions =
data->mFunctions;
InfallibleTArray<RefPtr<RawServoAnimationValue>>& startValues =
data->mStartValues;
InfallibleTArray<RefPtr<RawServoAnimationValue>>& endValues =
data->mEndValues;
@@ -667,17 +667,17 @@ AnimationHelper::SampleAnimations(Compos
}
case eCSSProperty_transform: {
RefPtr<nsCSSValueSharedList> list;
Servo_AnimationValue_GetTransform(animationValue, &list);
const TransformData& transformData = animation.data().get_TransformData();
nsPoint origin = transformData.origin();
// we expect all our transform data to arrive in device pixels
gfx::Point3D transformOrigin = transformData.transformOrigin();
- nsDisplayTransform::FrameTransformProperties props(Move(list),
+ nsDisplayTransform::FrameTransformProperties props(std::move(list),
transformOrigin);
gfx::Matrix4x4 transform =
nsDisplayTransform::GetResultingTransformMatrix(props, origin,
transformData.appUnitsPerDevPixel(),
0, &transformData.bounds());
gfx::Matrix4x4 frameTransform = transform;
// If the parent has perspective transform, then the offset into reference
@@ -689,17 +689,17 @@ AnimationHelper::SampleAnimations(Compos
true);
}
transform.PostScale(transformData.inheritedXScale(),
transformData.inheritedYScale(),
1);
aStorage->SetAnimatedValue(iter.Key(),
- Move(transform), Move(frameTransform),
+ std::move(transform), std::move(frameTransform),
transformData);
break;
}
default:
MOZ_ASSERT_UNREACHABLE("Unhandled animated property");
}
}
--- a/gfx/layers/AnimationHelper.h
+++ b/gfx/layers/AnimationHelper.h
@@ -63,18 +63,18 @@ struct AnimatedValue {
float mOpacity;
};
AnimatedValue(gfx::Matrix4x4&& aTransformInDevSpace,
gfx::Matrix4x4&& aFrameTransform,
const TransformData& aData)
: mType(AnimatedValue::TRANSFORM)
{
- mTransform.mTransformInDevSpace = Move(aTransformInDevSpace);
- mTransform.mFrameTransform = Move(aFrameTransform);
+ mTransform.mTransformInDevSpace = std::move(aTransformInDevSpace);
+ mTransform.mFrameTransform = std::move(aFrameTransform);
mTransform.mData = aData;
}
explicit AnimatedValue(const float& aValue)
: mType(AnimatedValue::OPACITY)
, mOpacity(aValue)
{
}
--- a/gfx/layers/BSPTree.cpp
+++ b/gfx/layers/BSPTree.cpp
@@ -30,32 +30,32 @@ BSPTree::BuildDrawOrder(BSPTreeNode* aNo
if (front) {
BuildDrawOrder(front, aLayers);
}
for (LayerPolygon& layer : aNode->layers) {
MOZ_ASSERT(layer.geometry);
if (layer.geometry->GetPoints().Length() >= 3) {
- aLayers.AppendElement(Move(layer));
+ aLayers.AppendElement(std::move(layer));
}
}
if (back) {
BuildDrawOrder(back, aLayers);
}
}
void
BSPTree::BuildTree(BSPTreeNode* aRoot,
std::list<LayerPolygon>& aLayers)
{
MOZ_ASSERT(!aLayers.empty());
- aRoot->layers.push_back(Move(aLayers.front()));
+ aRoot->layers.push_back(std::move(aLayers.front()));
aLayers.pop_front();
if (aLayers.empty()) {
return;
}
const gfx::Polygon& plane = aRoot->First();
MOZ_ASSERT(!plane.IsEmpty());
@@ -69,43 +69,43 @@ BSPTree::BuildTree(BSPTreeNode* aRoot,
// Calculate the plane-point distances for the polygon classification.
size_t pos = 0, neg = 0;
nsTArray<float> distances =
CalculatePointPlaneDistances(geometry, planeNormal, planePoint, pos, neg);
// Back polygon
if (pos == 0 && neg > 0) {
- backLayers.push_back(Move(layerPolygon));
+ backLayers.push_back(std::move(layerPolygon));
}
// Front polygon
else if (pos > 0 && neg == 0) {
- frontLayers.push_back(Move(layerPolygon));
+ frontLayers.push_back(std::move(layerPolygon));
}
// Coplanar polygon
else if (pos == 0 && neg == 0) {
- aRoot->layers.push_back(Move(layerPolygon));
+ aRoot->layers.push_back(std::move(layerPolygon));
}
// Polygon intersects with the splitting plane.
else if (pos > 0 && neg > 0) {
nsTArray<gfx::Point4D> backPoints, frontPoints;
// Clip the polygon against the plane. We reuse the previously calculated
// distances to find the plane-edge intersections.
ClipPointsWithPlane(geometry, planeNormal, distances,
backPoints, frontPoints);
const gfx::Point4D& normal = layerPolygon.geometry->GetNormal();
Layer* layer = layerPolygon.layer;
if (backPoints.Length() >= 3) {
- backLayers.emplace_back(layer, Move(backPoints), normal);
+ backLayers.emplace_back(layer, std::move(backPoints), normal);
}
if (frontPoints.Length() >= 3) {
- frontLayers.emplace_back(layer, Move(frontPoints), normal);
+ frontLayers.emplace_back(layer, std::move(frontPoints), normal);
}
}
}
if (!backLayers.empty()) {
aRoot->back = new (mPool) BSPTreeNode(mListPointers);
BuildTree(aRoot->back, backLayers);
}
--- a/gfx/layers/BSPTree.h
+++ b/gfx/layers/BSPTree.h
@@ -24,24 +24,24 @@ class Layer;
* Represents a layer that might have a non-rectangular geometry.
*/
struct LayerPolygon {
explicit LayerPolygon(Layer* aLayer)
: layer(aLayer) {}
LayerPolygon(Layer* aLayer,
gfx::Polygon&& aGeometry)
- : layer(aLayer), geometry(Some(Move(aGeometry))) {}
+ : layer(aLayer), geometry(Some(std::move(aGeometry))) {}
LayerPolygon(Layer* aLayer,
nsTArray<gfx::Point4D>&& aPoints,
const gfx::Point4D& aNormal)
: layer(aLayer)
{
- geometry.emplace(Move(aPoints), aNormal);
+ geometry.emplace(std::move(aPoints), aNormal);
}
Layer* layer;
Maybe<gfx::Polygon> geometry;
};
/**
* Allocate BSPTreeNodes from a memory arena to improve performance with
--- a/gfx/layers/Compositor.cpp
+++ b/gfx/layers/Compositor.cpp
@@ -290,17 +290,17 @@ GenerateTexturedTriangles(const gfx::Pol
MOZ_ASSERT(rect.Width() > 0.0f && rect.Height() > 0.0f);
MOZ_ASSERT(intersection.Width() > 0.0f && intersection.Height() > 0.0f);
// Since the texture was created for non-split geometry, we need to
// update the texture coordinates to account for the split.
gfx::TexturedTriangle t(triangle);
UpdateTextureCoordinates(t, rect, intersection, texRect);
- texturedTriangles.AppendElement(Move(t));
+ texturedTriangles.AppendElement(std::move(t));
}
}
return texturedTriangles;
}
nsTArray<TexturedVertex>
TexturedTrianglesToVertexArray(const nsTArray<gfx::TexturedTriangle>& aTriangles)
--- a/gfx/layers/FrameMetrics.h
+++ b/gfx/layers/FrameMetrics.h
@@ -871,17 +871,17 @@ public:
def.mMetrics.SetPresShellId(mMetrics.GetPresShellId());
return (def == *this);
}
FrameMetrics& GetMetrics() { return mMetrics; }
const FrameMetrics& GetMetrics() const { return mMetrics; }
void SetSnapInfo(ScrollSnapInfo&& aSnapInfo) {
- mSnapInfo = Move(aSnapInfo);
+ mSnapInfo = std::move(aSnapInfo);
}
const ScrollSnapInfo& GetSnapInfo() const { return mSnapInfo; }
ViewID GetScrollParentId() const {
return mScrollParentId;
}
void SetScrollParentId(ViewID aParentId) {
--- a/gfx/layers/ImageContainer.cpp
+++ b/gfx/layers/ImageContainer.cpp
@@ -69,30 +69,30 @@ void
BufferRecycleBin::RecycleBuffer(UniquePtr<uint8_t[]> aBuffer, uint32_t aSize)
{
MutexAutoLock lock(mLock);
if (!mRecycledBuffers.IsEmpty() && aSize != mRecycledBufferSize) {
mRecycledBuffers.Clear();
}
mRecycledBufferSize = aSize;
- mRecycledBuffers.AppendElement(Move(aBuffer));
+ mRecycledBuffers.AppendElement(std::move(aBuffer));
}
UniquePtr<uint8_t[]>
BufferRecycleBin::GetBuffer(uint32_t aSize)
{
MutexAutoLock lock(mLock);
if (mRecycledBuffers.IsEmpty() || mRecycledBufferSize != aSize) {
return UniquePtr<uint8_t[]>(new (fallible) uint8_t[aSize]);
}
uint32_t last = mRecycledBuffers.Length() - 1;
- UniquePtr<uint8_t[]> result = Move(mRecycledBuffers[last]);
+ UniquePtr<uint8_t[]> result = std::move(mRecycledBuffers[last]);
mRecycledBuffers.RemoveElementAt(last);
return result;
}
void
BufferRecycleBin::ClearRecycledBuffers()
{
MutexAutoLock lock(mLock);
@@ -488,17 +488,17 @@ PlanarYCbCrImage::PlanarYCbCrImage()
, mOffscreenFormat(SurfaceFormat::UNKNOWN)
, mBufferSize(0)
{
}
RecyclingPlanarYCbCrImage::~RecyclingPlanarYCbCrImage()
{
if (mBuffer) {
- mRecycleBin->RecycleBuffer(Move(mBuffer), mBufferSize);
+ mRecycleBin->RecycleBuffer(std::move(mBuffer), mBufferSize);
}
}
size_t
RecyclingPlanarYCbCrImage::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const
{
// Ignoring:
// - mData - just wraps mBuffer
--- a/gfx/layers/LayerScope.cpp
+++ b/gfx/layers/LayerScope.cpp
@@ -471,17 +471,17 @@ public:
UniquePtr<Packet> aPacket)
: DebugGLData(Packet::TEXTURE),
mLayerRef(reinterpret_cast<uint64_t>(layerRef)),
mTarget(target),
mName(name),
mContextAddress(reinterpret_cast<intptr_t>(cx)),
mDatasize(0),
mIsMask(aIsMask),
- mPacket(Move(aPacket))
+ mPacket(std::move(aPacket))
{
// pre-packing
// DataSourceSurface may have locked buffer,
// so we should compress now, and then it could
// be unlocked outside.
pack(img);
}
@@ -575,17 +575,17 @@ protected:
uint32_t mColor;
IntSize mSize;
};
class DebugGLLayersData final: public DebugGLData {
public:
explicit DebugGLLayersData(UniquePtr<Packet> aPacket)
: DebugGLData(Packet::LAYERS),
- mPacket(Move(aPacket))
+ mPacket(std::move(aPacket))
{ }
virtual bool Write() override {
mPacket->set_type(mDataType);
return WriteToStream(*mPacket);
}
protected:
@@ -997,17 +997,17 @@ SenderHelper::SendTextureSource(GLContex
// By sending 0 to ReadTextureImage rely upon aSource->BindTexture binding
// texture correctly. texID is used for tracking in DebugGLTextureData.
RefPtr<DataSourceSurface> img =
aGLContext->ReadTexImageHelper()->ReadTexImage(0, textureTarget,
size,
shaderConfig, aFlipY);
gLayerScopeManager.GetSocketManager()->AppendDebugData(
new DebugGLTextureData(aGLContext, aLayerRef, textureTarget,
- texID, img, aIsMask, Move(aPacket)));
+ texID, img, aIsMask, std::move(aPacket)));
sSentTextureIds.push_back(texID);
gLayerScopeManager.CurrentSession().mTexIDs.push_back(texID);
}
void
SenderHelper::SetAndSendTexture(GLContext* aGLContext,
@@ -1016,17 +1016,17 @@ SenderHelper::SetAndSendTexture(GLContex
const TexturedEffect* aEffect)
{
// Expose packet creation here, so we could dump primary texture effect attributes.
auto packet = MakeUnique<layerscope::Packet>();
layerscope::TexturePacket* texturePacket = packet->mutable_texture();
texturePacket->set_mpremultiplied(aEffect->mPremultiplied);
DumpFilter(texturePacket, aEffect->mSamplingFilter);
DumpRect(texturePacket->mutable_mtexturecoords(), aEffect->mTextureCoords);
- SendTextureSource(aGLContext, aLayerRef, aSource, false, false, Move(packet));
+ SendTextureSource(aGLContext, aLayerRef, aSource, false, false, std::move(packet));
}
void
SenderHelper::SendTexturedEffect(GLContext* aGLContext,
void* aLayerRef,
const TexturedEffect* aEffect)
{
TextureSourceOGL* source = aEffect->mTexture->AsSourceOGL();
@@ -1053,17 +1053,17 @@ SenderHelper::SendMaskEffect(GLContext*
TexturePacket::EffectMask* mask = packet->mutable_texture()->mutable_mask();
mask->mutable_msize()->set_w(aEffect->mSize.width);
mask->mutable_msize()->set_h(aEffect->mSize.height);
auto element = reinterpret_cast<const Float *>(&(aEffect->mMaskTransform));
for (int i = 0; i < 16; i++) {
mask->mutable_mmasktransform()->add_m(*element++);
}
- SendTextureSource(aGLContext, aLayerRef, source, false, true, Move(packet));
+ SendTextureSource(aGLContext, aLayerRef, source, false, true, std::move(packet));
}
void
SenderHelper::SendYCbCrEffect(GLContext* aGLContext,
void* aLayerRef,
const EffectYCbCr* aEffect)
{
TextureSource* sourceYCbCr = aEffect->mTexture;
@@ -1737,17 +1737,17 @@ LayerScope::SendLayer(LayerComposite* aL
void
LayerScope::SendLayerDump(UniquePtr<Packet> aPacket)
{
// Protect this public function
if (!CheckSendable() || !SenderHelper::GetLayersTreeSendable()) {
return;
}
gLayerScopeManager.GetSocketManager()->AppendDebugData(
- new DebugGLLayersData(Move(aPacket)));
+ new DebugGLLayersData(std::move(aPacket)));
}
/*static*/
bool
LayerScope::CheckSendable()
{
// Only compositor threads check LayerScope status
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread() || gIsGtest);
--- a/gfx/layers/LayerTreeInvalidation.cpp
+++ b/gfx/layers/LayerTreeInvalidation.cpp
@@ -277,17 +277,17 @@ public:
}
mLayer->ClearInvalidRegion();
if (areaOverflowed) {
return false;
}
- aOutRegion = Move(result);
+ aOutRegion = std::move(result);
return true;
}
void CheckCanary()
{
mCanary.Check();
mLayer->CheckCanary();
}
@@ -341,17 +341,17 @@ struct ContainerLayerProperties : public
{
explicit ContainerLayerProperties(ContainerLayer* aLayer)
: LayerPropertiesBase(aLayer)
, mPreXScale(aLayer->GetPreXScale())
, mPreYScale(aLayer->GetPreYScale())
{
for (Layer* child = aLayer->GetFirstChild(); child; child = child->GetNextSibling()) {
child->CheckCanary();
- mChildren.AppendElement(Move(CloneLayerTreePropertiesInternal(child)));
+ mChildren.AppendElement(std::move(CloneLayerTreePropertiesInternal(child)));
}
}
protected:
ContainerLayerProperties(const ContainerLayerProperties& a) = delete;
ContainerLayerProperties& operator=(const ContainerLayerProperties& a) = delete;
public:
@@ -509,17 +509,17 @@ public:
// |result| contains invalid regions only of children.
result.Transform(GetTransformForInvalidation(mLayer).GetMatrix());
}
// else, effective transforms have applied on children.
LTI_DUMP(invalidOfLayer, "invalidOfLayer");
result.OrWith(invalidOfLayer);
- aOutRegion = Move(result);
+ aOutRegion = std::move(result);
return true;
}
Maybe<IntRect> NewTransformedBounds() override
{
if (mLayer->Extend3DContext()) {
IntRect result;
for (UniquePtr<LayerPropertiesBase>& child : mChildren) {
--- a/gfx/layers/Layers.cpp
+++ b/gfx/layers/Layers.cpp
@@ -1140,17 +1140,17 @@ SortLayersWithBSPTree(nsTArray<Layer*>&
}
gfx::Polygon polygon = gfx::Polygon::FromRect(gfx::Rect(bounds));
// Transform the polygon to screen space.
polygon.TransformToScreenSpace(transform);
if (polygon.GetPoints().Length() >= 3) {
- inputLayers.push_back(LayerPolygon(layer, Move(polygon)));
+ inputLayers.push_back(LayerPolygon(layer, std::move(polygon)));
}
}
if (inputLayers.empty()) {
return nsTArray<LayerPolygon>();
}
// Build a BSP tree from the list of polygons.
@@ -1201,17 +1201,17 @@ ContainerLayer::SortChildrenBy3DZOrder(S
!container->UseIntermediateSurface()) {
// Collect 3D layers in toSort array.
container->Collect3DContextLeaves(toSort);
// Sort the 3D layers.
if (toSort.Length() > 0) {
nsTArray<LayerPolygon> sorted = SortLayersWithBSPTree(toSort);
- drawOrder.AppendElements(Move(sorted));
+ drawOrder.AppendElements(std::move(sorted));
toSort.ClearAndRetainStorage();
}
continue;
}
drawOrder.AppendElement(LayerPolygon(layer));
--- a/gfx/layers/PaintThread.cpp
+++ b/gfx/layers/PaintThread.cpp
@@ -207,17 +207,17 @@ PaintThread::Shutdown()
UniquePtr<PaintThread> pt(sSingleton.forget());
if (!pt) {
return;
}
sThread->Dispatch(NewRunnableFunction("DestroyPaintThreadRunnable",
DestroyPaintThread,
- Move(pt)));
+ std::move(pt)));
sThread->Shutdown();
sThread = nullptr;
}
void
PaintThread::ShutdownOnPaintThread()
{
MOZ_ASSERT(IsOnPaintThread());
--- a/gfx/layers/ProfilerScreenshots.cpp
+++ b/gfx/layers/ProfilerScreenshots.cpp
@@ -100,17 +100,17 @@ ProfilerScreenshots::SubmitScreenshot(ui
NS_LITERAL_STRING("quality=85"),
gfxUtils::eDataURIEncode,
nullptr, &dataURL);
if (NS_SUCCEEDED(rv)) {
// Add a marker with the data URL.
profiler_add_marker_for_thread(
sourceThread,
"CompositorScreenshot",
- MakeUnique<ScreenshotPayload>(timeStamp, Move(dataURL),
+ MakeUnique<ScreenshotPayload>(timeStamp, std::move(dataURL),
originalSize, windowIdentifier));
}
}
// Return backingSurface back to the surface pool.
ReturnSurface(backingSurface);
}));
#endif
--- a/gfx/layers/ShareableCanvasRenderer.cpp
+++ b/gfx/layers/ShareableCanvasRenderer.cpp
@@ -60,24 +60,24 @@ ShareableCanvasRenderer::Initialize(cons
}
UniquePtr<gl::SurfaceFactory> factory =
gl::GLScreenBuffer::CreateFactory(mGLContext, caps, forwarder, mFlags);
if (mGLFrontbuffer) {
// We're using a source other than the one in the default screen.
// (SkiaGL)
- mFactory = Move(factory);
+ mFactory = std::move(factory);
if (!mFactory) {
// Absolutely must have a factory here, so create a basic one
mFactory = MakeUnique<gl::SurfaceFactory_Basic>(mGLContext, caps, mFlags);
}
} else {
if (factory)
- screen->Morph(Move(factory));
+ screen->Morph(std::move(factory));
}
}
void
ShareableCanvasRenderer::ClearCachedResources()
{
CopyableCanvasRenderer::ClearCachedResources();
--- a/gfx/layers/SourceSurfaceSharedData.cpp
+++ b/gfx/layers/SourceSurfaceSharedData.cpp
@@ -181,19 +181,19 @@ SourceSurfaceSharedData::ReallocHandle()
size_t copyLen = GetDataLength();
memcpy(buf->memory(), mBuf->memory(), copyLen);
#ifdef SHARED_SURFACE_PROTECT_FINALIZED
buf->Protect(static_cast<char*>(buf->memory()), len, RightsRead);
#endif
if (mMapCount > 0 && !mOldBuf) {
- mOldBuf = Move(mBuf);
+ mOldBuf = std::move(mBuf);
}
- mBuf = Move(buf);
+ mBuf = std::move(buf);
mClosed = false;
mShared = false;
return true;
}
void
SourceSurfaceSharedData::Finalize()
{
--- a/gfx/layers/apz/src/APZCTreeManager.cpp
+++ b/gfx/layers/apz/src/APZCTreeManager.cpp
@@ -297,23 +297,23 @@ APZCTreeManager::NotifyLayerTreeAdopted(
// that information repopulated soon anyway (on the next layers update).
}
UniquePtr<APZTestData> adoptedData;
if (aOldApzcTreeManager) {
MutexAutoLock lock(aOldApzcTreeManager->mTestDataLock);
auto it = aOldApzcTreeManager->mTestData.find(aLayersId);
if (it != aOldApzcTreeManager->mTestData.end()) {
- adoptedData = Move(it->second);
+ adoptedData = std::move(it->second);
aOldApzcTreeManager->mTestData.erase(it);
}
}
if (adoptedData) {
MutexAutoLock lock(mTestDataLock);
- mTestData[aLayersId] = Move(adoptedData);
+ mTestData[aLayersId] = std::move(adoptedData);
}
}
void
APZCTreeManager::NotifyLayerTreeRemoved(LayersId aLayersId)
{
AssertOnUpdaterThread();
@@ -358,17 +358,17 @@ APZCTreeManager::UpdateHitTestingTreeImp
RecursiveMutexAutoLock lock(mTreeLock);
// For testing purposes, we log some data to the APZTestData associated with
// the layers id that originated this update.
APZTestData* testData = nullptr;
if (gfxPrefs::APZTestLoggingEnabled()) {
MutexAutoLock lock(mTestDataLock);
UniquePtr<APZTestData> ptr = MakeUnique<APZTestData>();
- auto result = mTestData.insert(std::make_pair(aOriginatingLayersId, Move(ptr)));
+ auto result = mTestData.insert(std::make_pair(aOriginatingLayersId, std::move(ptr)));
testData = result.first->second.get();
testData->StartNewPaint(aPaintSequenceNumber);
}
TreeBuildingState state(aRootLayerTreeId, aIsFirstPaint, aOriginatingLayersId,
testData, aPaintSequenceNumber);
// We do this business with collecting the entire tree into an array because otherwise
@@ -502,17 +502,17 @@ APZCTreeManager::UpdateHitTestingTreeImp
}
// We do not support tree structures where the root node has siblings.
MOZ_ASSERT(!(mRootNode && mRootNode->GetPrevSibling()));
{ // scope lock and update our mApzcMap before we destroy all the unused
// APZC instances
MutexAutoLock lock(mMapLock);
- mApzcMap = Move(state.mApzcMap);
+ mApzcMap = std::move(state.mApzcMap);
mScrollThumbInfo.clear();
// For non-webrender, state.mScrollThumbs will be empty so this will be a
// no-op.
for (HitTestingTreeNode* thumb : state.mScrollThumbs) {
MOZ_ASSERT(thumb->IsScrollThumbNode());
ScrollableLayerGuid targetGuid(thumb->GetLayersId(), 0, thumb->GetScrollTargetId());
auto it = state.mScrollTargets.find(targetGuid);
if (it == state.mScrollTargets.end()) {
--- a/gfx/layers/apz/src/APZUpdater.cpp
+++ b/gfx/layers/apz/src/APZUpdater.cpp
@@ -444,17 +444,17 @@ APZUpdater::IsUpdaterThread() const
void
APZUpdater::RunOnControllerThread(LayersId aLayersId, already_AddRefed<Runnable> aTask)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
RunOnUpdaterThread(aLayersId, NewRunnableFunction(
"APZUpdater::RunOnControllerThread",
&APZThreadUtils::RunOnControllerThread,
- Move(aTask)));
+ std::move(aTask)));
}
bool
APZUpdater::UsingWebRenderUpdaterThread() const
{
return (mIsUsingWebRender && gfxPrefs::WebRenderAsyncSceneBuild());
}
--- a/gfx/layers/apz/src/AndroidDynamicToolbarAnimator.cpp
+++ b/gfx/layers/apz/src/AndroidDynamicToolbarAnimator.cpp
@@ -502,17 +502,17 @@ AndroidDynamicToolbarAnimator::NotifyLay
PostMessage(LAYERS_UPDATED);
}
}
void
AndroidDynamicToolbarAnimator::AdoptToolbarPixels(mozilla::ipc::Shmem&& aMem, const ScreenIntSize& aSize)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
- mCompositorToolbarPixels = Some(Move(aMem));
+ mCompositorToolbarPixels = Some(std::move(aMem));
mCompositorToolbarPixelsSize = aSize;
}
void
AndroidDynamicToolbarAnimator::UpdateToolbarSnapshotTexture(CompositorOGL* gl)
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
// if the compositor has shutdown, do not create any new rendering objects.
--- a/gfx/layers/apz/src/AsyncPanZoomAnimation.h
+++ b/gfx/layers/apz/src/AsyncPanZoomAnimation.h
@@ -43,17 +43,17 @@ public:
return DoSample(aFrameMetrics, aDelta);
}
/**
* Get the deferred tasks in |mDeferredTasks| and place them in |aTasks|. See
* |mDeferredTasks| for more information. Clears |mDeferredTasks|.
*/
nsTArray<RefPtr<Runnable>> TakeDeferredTasks() {
- return Move(mDeferredTasks);
+ return std::move(mDeferredTasks);
}
virtual KeyboardScrollAnimation* AsKeyboardScrollAnimation() {
return nullptr;
}
virtual WheelScrollAnimation* AsWheelScrollAnimation() {
return nullptr;
}
--- a/gfx/layers/apz/test/gtest/APZTestCommon.h
+++ b/gfx/layers/apz/test/gtest/APZTestCommon.h
@@ -83,17 +83,17 @@ public:
// Can't use the macros with already_AddRefed :(
void PostDelayedTask(already_AddRefed<Runnable> aTask, int aDelayMs) {
RefPtr<Runnable> task = aTask;
}
bool IsRepaintThread() {
return NS_IsMainThread();
}
void DispatchToRepaintThread(already_AddRefed<Runnable> aTask) {
- NS_DispatchToMainThread(Move(aTask));
+ NS_DispatchToMainThread(std::move(aTask));
}
MOCK_METHOD3(NotifyAPZStateChange, void(const ScrollableLayerGuid& aGuid, APZStateChange aChange, int aArg));
MOCK_METHOD0(NotifyFlushComplete, void());
MOCK_METHOD1(NotifyAsyncScrollbarDragRejected, void(const FrameMetrics::ViewID&));
MOCK_METHOD1(NotifyAsyncAutoscrollRejected, void(const FrameMetrics::ViewID&));
MOCK_METHOD1(CancelAutoscroll, void(const ScrollableLayerGuid&));
};
--- a/gfx/layers/apz/util/APZCCallbackHelper.cpp
+++ b/gfx/layers/apz/util/APZCCallbackHelper.cpp
@@ -739,17 +739,17 @@ public:
void DidRefresh() override {
if (!mPresShell) {
MOZ_ASSERT_UNREACHABLE("Post-refresh observer fired again after failed attempt at unregistering it");
return;
}
APZCCH_LOG("Got refresh, sending target APZCs for input block %" PRIu64 "\n", mInputBlockId);
- SendLayersDependentApzcTargetConfirmation(mPresShell, mInputBlockId, Move(mTargets));
+ SendLayersDependentApzcTargetConfirmation(mPresShell, mInputBlockId, std::move(mTargets));
if (!mPresShell->RemovePostRefreshObserver(this)) {
MOZ_ASSERT_UNREACHABLE("Unable to unregister post-refresh observer! Leaking it instead of leaving garbage registered");
// Graceful handling, just in case...
mPresShell = nullptr;
return;
}
@@ -770,17 +770,17 @@ SendSetTargetAPZCNotificationHelper(nsIW
const uint64_t& aInputBlockId,
const nsTArray<ScrollableLayerGuid>& aTargets,
bool aWaitForRefresh)
{
bool waitForRefresh = aWaitForRefresh;
if (waitForRefresh) {
APZCCH_LOG("At least one target got a new displayport, need to wait for refresh\n");
waitForRefresh = aShell->AddPostRefreshObserver(
- new DisplayportSetListener(aShell, aInputBlockId, Move(aTargets)));
+ new DisplayportSetListener(aShell, aInputBlockId, std::move(aTargets)));
}
if (!waitForRefresh) {
APZCCH_LOG("Sending target APZCs for input block %" PRIu64 "\n", aInputBlockId);
aWidget->SetConfirmedTargetAPZC(aInputBlockId, aTargets);
} else {
APZCCH_LOG("Successfully registered post-refresh observer\n");
}
}
@@ -826,17 +826,17 @@ APZCCallbackHelper::SendSetTargetAPZCNot
}
// TODO: Do other types of events need to be handled?
if (!targets.IsEmpty()) {
SendSetTargetAPZCNotificationHelper(
aWidget,
shell,
aInputBlockId,
- Move(targets),
+ std::move(targets),
waitForRefresh);
}
return waitForRefresh;
}
}
return false;
}
@@ -854,17 +854,17 @@ APZCCallbackHelper::SendSetAllowedTouchB
rootFrame = UpdateRootFrameForTouchTargetDocument(rootFrame);
nsTArray<TouchBehaviorFlags> flags;
for (uint32_t i = 0; i < aEvent.mTouches.Length(); i++) {
flags.AppendElement(
TouchActionHelper::GetAllowedTouchBehavior(aWidget,
rootFrame, aEvent.mTouches[i]->mRefPoint));
}
- aCallback(aInputBlockId, Move(flags));
+ aCallback(aInputBlockId, std::move(flags));
}
}
}
void
APZCCallbackHelper::NotifyMozMouseScrollEvent(const FrameMetrics::ViewID& aScrollId, const nsString& aEvent)
{
nsCOMPtr<nsIContent> targetContent = nsLayoutUtils::FindContentFor(aScrollId);
--- a/gfx/layers/apz/util/APZEventState.cpp
+++ b/gfx/layers/apz/util/APZEventState.cpp
@@ -96,17 +96,17 @@ namespace layers {
static int32_t sActiveDurationMs = 10;
static bool sActiveDurationMsSet = false;
APZEventState::APZEventState(nsIWidget* aWidget,
ContentReceivedInputBlockCallback&& aCallback)
: mWidget(nullptr) // initialized in constructor body
, mActiveElementManager(new ActiveElementManager())
- , mContentReceivedInputBlockCallback(Move(aCallback))
+ , mContentReceivedInputBlockCallback(std::move(aCallback))
, mPendingTouchPreventedResponse(false)
, mPendingTouchPreventedBlockId(0)
, mEndTouchIsClick(false)
, mTouchEndCancelled(false)
, mLastTouchIdentifier(0)
{
nsresult rv;
mWidget = do_GetWeakReference(aWidget, &rv);
--- a/gfx/layers/apz/util/ChromeProcessController.cpp
+++ b/gfx/layers/apz/util/ChromeProcessController.cpp
@@ -63,29 +63,29 @@ ChromeProcessController::RequestContentR
} else {
APZCCallbackHelper::UpdateSubFrame(metrics);
}
}
void
ChromeProcessController::PostDelayedTask(already_AddRefed<Runnable> aTask, int aDelayMs)
{
- MessageLoop::current()->PostDelayedTask(Move(aTask), aDelayMs);
+ MessageLoop::current()->PostDelayedTask(std::move(aTask), aDelayMs);
}
bool
ChromeProcessController::IsRepaintThread()
{
return NS_IsMainThread();
}
void
ChromeProcessController::DispatchToRepaintThread(already_AddRefed<Runnable> aTask)
{
- NS_DispatchToMainThread(Move(aTask));
+ NS_DispatchToMainThread(std::move(aTask));
}
void
ChromeProcessController::Destroy()
{
if (MessageLoop::current() != mUILoop) {
mUILoop->PostTask(
NewRunnableMethod("layers::ChromeProcessController::Destroy",
--- a/gfx/layers/apz/util/ContentProcessController.cpp
+++ b/gfx/layers/apz/util/ContentProcessController.cpp
@@ -115,13 +115,13 @@ bool
ContentProcessController::IsRepaintThread()
{
return NS_IsMainThread();
}
void
ContentProcessController::DispatchToRepaintThread(already_AddRefed<Runnable> aTask)
{
- NS_DispatchToMainThread(Move(aTask));
+ NS_DispatchToMainThread(std::move(aTask));
}
} // namespace layers
} // namespace mozilla
--- a/gfx/layers/basic/BasicImages.cpp
+++ b/gfx/layers/basic/BasicImages.cpp
@@ -41,17 +41,17 @@ public:
SetOffscreenFormat(aOffscreenFormat);
}
~BasicPlanarYCbCrImage()
{
if (mDecodedBuffer) {
// Right now this only happens if the Image was never drawn, otherwise
// this will have been tossed away at surface destruction.
- mRecycleBin->RecycleBuffer(Move(mDecodedBuffer), mSize.height * mStride);
+ mRecycleBin->RecycleBuffer(std::move(mDecodedBuffer), mSize.height * mStride);
}
}
virtual bool CopyData(const Data& aData) override;
virtual void SetDelayedConversion(bool aDelayed) override { mDelayedConversion = aDelayed; }
already_AddRefed<gfx::SourceSurface> GetAsSourceSurface() override;
@@ -160,17 +160,17 @@ BasicPlanarYCbCrImage::GetAsSourceSurfac
gfx::ImageFormatToSurfaceFormat(format));
if (!drawTarget) {
return nullptr;
}
surface = drawTarget->Snapshot();
}
- mRecycleBin->RecycleBuffer(Move(mDecodedBuffer), mSize.height * mStride);
+ mRecycleBin->RecycleBuffer(std::move(mDecodedBuffer), mSize.height * mStride);
mSourceSurface = surface;
return surface.forget();
}
ImageFactory*
BasicLayerManager::GetImageFactory()
--- a/gfx/layers/client/ContentClient.cpp
+++ b/gfx/layers/client/ContentClient.cpp
@@ -166,17 +166,17 @@ ContentClient::BeginPaint(PaintedLayer*
if (mBuffer) {
if (mBuffer->Lock(lockMode)) {
// Do not modify result.mRegionToDraw or result.mContentType after this call.
Maybe<CapturedBufferState::Copy> bufferFinalize =
FinalizeFrame(result.mRegionToDraw);
if (asyncPaint) {
- result.mBufferState->mBufferFinalize = Move(bufferFinalize);
+ result.mBufferState->mBufferFinalize = std::move(bufferFinalize);
} else if (bufferFinalize) {
bufferFinalize->CopyBuffer();
}
} else {
result.mRegionToDraw = dest.mNeededRegion;
dest.mCanReuseBuffer = false;
Clear();
}
@@ -200,17 +200,17 @@ ContentClient::BeginPaint(PaintedLayer*
// If we're async painting then return the buffer state to
// be dispatched to the paint thread, otherwise do it now
if (asyncPaint) {
// We cannot do a buffer unrotate if the buffer is already rotated
// and we're async painting as that may fail
if (!bufferUnrotate ||
mBuffer->BufferRotation() == IntPoint(0,0)) {
- result.mBufferState->mBufferUnrotate = Move(bufferUnrotate);
+ result.mBufferState->mBufferUnrotate = std::move(bufferUnrotate);
// We can then assume that preparing the buffer will always
// succeed and update our parameters unconditionally
if (result.mBufferState->mBufferUnrotate) {
newParameters.SetUnrotated();
}
mBuffer->SetParameters(newParameters);
canReuseBuffer = true;
@@ -281,17 +281,17 @@ ContentClient::BeginPaint(PaintedLayer*
mBuffer->ShallowCopy(),
newBuffer->ShallowCopy(),
updateRegion.GetBounds(),
};
// If we're async painting then return the buffer state to
// be dispatched to the paint thread, otherwise do it now
if (asyncPaint) {
- result.mBufferState->mBufferInitialize = Some(Move(bufferInitialize));
+ result.mBufferState->mBufferInitialize = Some(std::move(bufferInitialize));
} else {
if (!bufferInitialize.CopyBuffer()) {
gfxCriticalNote << "Failed to copy front buffer to back buffer.";
return result;
}
}
}
}
@@ -511,18 +511,18 @@ ContentClient::CalculateBufferForPaint(P
}
break;
}
NS_ASSERTION(destBufferRect.Contains(neededRegion.GetBounds()),
"Destination rect doesn't contain what we need to paint");
BufferDecision dest;
- dest.mNeededRegion = Move(neededRegion);
- dest.mValidRegion = Move(validRegion);
+ dest.mNeededRegion = std::move(neededRegion);
+ dest.mValidRegion = std::move(validRegion);
dest.mBufferRect = destBufferRect;
dest.mBufferMode = mode;
dest.mBufferContentType = contentType;
dest.mCanReuseBuffer = canReuseBuffer;
dest.mCanKeepBufferContents = canKeepBufferContents;
return dest;
}
--- a/gfx/layers/client/TextureClient.cpp
+++ b/gfx/layers/client/TextureClient.cpp
@@ -1447,17 +1447,17 @@ void
TextureClient::GPUVideoDesc(SurfaceDescriptorGPUVideo* const aOutDesc)
{
const auto handle = GetSerial();
GPUVideoSubDescriptor subDesc = null_t();
MOZ_RELEASE_ASSERT(mData);
mData->GetSubDescriptor(&subDesc);
- *aOutDesc = SurfaceDescriptorGPUVideo(handle, Move(subDesc));
+ *aOutDesc = SurfaceDescriptorGPUVideo(handle, std::move(subDesc));
}
class MemoryTextureReadLock : public NonBlockingTextureReadLock {
public:
MemoryTextureReadLock();
~MemoryTextureReadLock();
--- a/gfx/layers/client/TextureClientSharedSurface.cpp
+++ b/gfx/layers/client/TextureClientSharedSurface.cpp
@@ -16,17 +16,17 @@
using namespace mozilla::gl;
namespace mozilla {
namespace layers {
SharedSurfaceTextureData::SharedSurfaceTextureData(UniquePtr<gl::SharedSurface> surf)
- : mSurf(Move(surf))
+ : mSurf(std::move(surf))
{}
SharedSurfaceTextureData::~SharedSurfaceTextureData()
{}
void
SharedSurfaceTextureData::Deallocate(LayersIPCChannel*)
{}
@@ -60,17 +60,17 @@ SharedSurfaceTextureClient::SharedSurfac
already_AddRefed<SharedSurfaceTextureClient>
SharedSurfaceTextureClient::Create(UniquePtr<gl::SharedSurface> surf, gl::SurfaceFactory* factory,
LayersIPCChannel* aAllocator, TextureFlags aFlags)
{
if (!surf) {
return nullptr;
}
TextureFlags flags = aFlags | TextureFlags::RECYCLE | surf->GetTextureFlags();
- SharedSurfaceTextureData* data = new SharedSurfaceTextureData(Move(surf));
+ SharedSurfaceTextureData* data = new SharedSurfaceTextureData(std::move(surf));
return MakeAndAddRef<SharedSurfaceTextureClient>(data, flags, aAllocator);
}
SharedSurfaceTextureClient::~SharedSurfaceTextureClient()
{
// XXX - Things break when using the proper destruction handshake with
// SharedSurfaceTextureData because the TextureData outlives its gl
// context. Having a strong reference to the gl context creates a cycle.
--- a/gfx/layers/composite/AsyncCompositionManager.cpp
+++ b/gfx/layers/composite/AsyncCompositionManager.cpp
@@ -580,17 +580,17 @@ ServoAnimationValueToMatrix4x4(const Ref
const TransformData& aTransformData)
{
// FIXME: Bug 1457033: We should convert servo's animation value to matrix
// directly without nsCSSValueSharedList.
RefPtr<nsCSSValueSharedList> list;
Servo_AnimationValue_GetTransform(aValue, &list);
// we expect all our transform data to arrive in device pixels
Point3D transformOrigin = aTransformData.transformOrigin();
- nsDisplayTransform::FrameTransformProperties props(Move(list),
+ nsDisplayTransform::FrameTransformProperties props(std::move(list),
transformOrigin);
return nsDisplayTransform::GetResultingTransformMatrix(
props, aTransformData.origin(),
aTransformData.appUnitsPerDevPixel(),
0, &aTransformData.bounds());
}
@@ -653,17 +653,17 @@ ApplyAnimatedValue(Layer* aLayer,
Matrix4x4 transform =
FrameTransformToTransformInDevice(frameTransform,
aLayer,
transformData);
layerCompositor->SetShadowBaseTransform(transform);
layerCompositor->SetShadowTransformSetByAnimation(true);
aStorage->SetAnimatedValue(aLayer->GetCompositorAnimationsId(),
- Move(transform), Move(frameTransform),
+ std::move(transform), std::move(frameTransform),
transformData);
layerCompositor->SetShadowOpacity(aLayer->GetOpacity());
layerCompositor->SetShadowOpacitySetByAnimation(false);
break;
}
default:
MOZ_ASSERT_UNREACHABLE("Unhandled animated property");
--- a/gfx/layers/composite/CompositorScreenshotGrabber.cpp
+++ b/gfx/layers/composite/CompositorScreenshotGrabber.cpp
@@ -235,15 +235,15 @@ CompositorScreenshotGrabberImpl::Process
item.mScreenshotSize);
});
ReturnBuffer(item.mScreenshotBuffer);
}
}
mQueue.Clear();
if (mCurrentFrameQueueItem) {
- mQueue.AppendElement(Move(*mCurrentFrameQueueItem));
+ mQueue.AppendElement(std::move(*mCurrentFrameQueueItem));
mCurrentFrameQueueItem = Nothing();
}
}
} // namespace layers
} // namespace mozilla
--- a/gfx/layers/composite/ContainerLayerComposite.cpp
+++ b/gfx/layers/composite/ContainerLayerComposite.cpp
@@ -165,17 +165,17 @@ static gfx::IntRect ContainerVisibleRect
/* all of the per-layer prepared data we need to maintain */
struct PreparedLayer
{
PreparedLayer(Layer *aLayer,
RenderTargetIntRect aClipRect,
Maybe<gfx::Polygon>&& aGeometry)
- : mLayer(aLayer), mClipRect(aClipRect), mGeometry(Move(aGeometry)) {}
+ : mLayer(aLayer), mClipRect(aClipRect), mGeometry(std::move(aGeometry)) {}
RefPtr<Layer> mLayer;
RenderTargetIntRect mClipRect;
Maybe<Polygon> mGeometry;
};
/* all of the prepared data that we need in RenderLayer() */
struct PreparedData
@@ -233,17 +233,17 @@ ContainerPrepare(ContainerT* aContainer,
}
}
CULLING_LOG("Preparing sublayer %p\n", layerToRender->GetLayer());
layerToRender->Prepare(clipRect);
aContainer->mPrepared->mLayers.AppendElement(PreparedLayer(layerToRender->GetLayer(),
clipRect,
- Move(layer.geometry)));
+ std::move(layer.geometry)));
}
CULLING_LOG("Preparing container layer %p\n", aContainer->GetLayer());
/**
* Setup our temporary surface for rendering the contents of this container.
*/
--- a/gfx/layers/composite/LayerManagerComposite.cpp
+++ b/gfx/layers/composite/LayerManagerComposite.cpp
@@ -497,17 +497,17 @@ LayerManagerComposite::UpdateAndRender()
if (mTarget) {
// Since we're composing to an external target, we're not going to use
// the damage region from layers changes - we want to composite
// everything in the target bounds. Instead we accumulate the layers
// damage region for the next window composite.
mInvalidRegion.Or(mInvalidRegion, changed);
} else {
- invalid = Move(changed);
+ invalid = std::move(changed);
}
}
if (mTarget) {
invalid.Or(invalid, mTargetBounds);
} else {
// If we didn't have a previous layer tree, invalidate the entire render
// area.
@@ -871,17 +871,17 @@ LayerManagerComposite::Render(const nsIn
// Dump to LayerScope Viewer
if (LayerScope::CheckSendable()) {
// Create a LayersPacket, dump Layers into it and transfer the
// packet('s ownership) to LayerScope.
auto packet = MakeUnique<layerscope::Packet>();
layerscope::LayersPacket* layersPacket = packet->mutable_layers();
this->Dump(layersPacket);
- LayerScope::SendLayerDump(Move(packet));
+ LayerScope::SendLayerDump(std::move(packet));
}
mozilla::widget::WidgetRenderingContext widgetContext;
#if defined(XP_MACOSX)
widgetContext.mLayerManager = this;
#elif defined(MOZ_WIDGET_ANDROID)
widgetContext.mCompositor = GetCompositor();
#endif
--- a/gfx/layers/composite/LayerManagerComposite.h
+++ b/gfx/layers/composite/LayerManagerComposite.h
@@ -125,17 +125,17 @@ public:
return this;
}
virtual LayerManagerMLGPU* AsLayerManagerMLGPU() {
return nullptr;
}
void ExtractImageCompositeNotifications(nsTArray<ImageCompositeNotificationInfo>* aNotifications)
{
- aNotifications->AppendElements(Move(mImageCompositeNotifications));
+ aNotifications->AppendElements(std::move(mImageCompositeNotifications));
}
void AppendImageCompositeNotification(const ImageCompositeNotificationInfo& aNotification)
{
// Only send composite notifications when we're drawing to the screen,
// because that's what they mean.
// Also when we're not drawing to the screen, DidComposite will not be
// called to extract and send these notifications, so they might linger
@@ -546,17 +546,17 @@ public:
* They are analogous to the Layer interface.
*/
void SetShadowVisibleRegion(const LayerIntRegion& aRegion)
{
mShadowVisibleRegion = aRegion;
}
void SetShadowVisibleRegion(LayerIntRegion&& aRegion)
{
- mShadowVisibleRegion = Move(aRegion);
+ mShadowVisibleRegion = std::move(aRegion);
}
void SetShadowOpacity(float aOpacity)
{
mShadowOpacity = aOpacity;
}
void SetShadowOpacitySetByAnimation(bool aSetByAnimation)
{
--- a/gfx/layers/composite/TextRenderer.cpp
+++ b/gfx/layers/composite/TextRenderer.cpp
@@ -227,14 +227,14 @@ TextRenderer::EnsureInitialized(FontType
png_set_progressive_read_fn(png_ptr, cache.get(), info_callback, row_callback, nullptr);
png_infop info_ptr = NULL;
info_ptr = png_create_info_struct(png_ptr);
png_process_data(png_ptr, info_ptr, (uint8_t*)info->mPNG, info->mPNGLength);
png_destroy_read_struct(&png_ptr, &info_ptr, nullptr);
- mFonts[aType] = Move(cache);
+ mFonts[aType] = std::move(cache);
return true;
}
} // namespace layers
} // namespace mozilla
--- a/gfx/layers/composite/TiledContentHost.cpp
+++ b/gfx/layers/composite/TiledContentHost.cpp
@@ -200,17 +200,17 @@ UseTileTexture(CompositableTextureHostRe
aTexture->PrepareTextureSource(aTextureSource);
}
class TextureSourceRecycler
{
public:
explicit TextureSourceRecycler(nsTArray<TileHost>&& aTileSet)
- : mTiles(Move(aTileSet))
+ : mTiles(std::move(aTileSet))
, mFirstPossibility(0)
{}
// Attempts to recycle a texture source that is already bound to the
// texture host for aTile.
void RecycleTextureSourceForTile(TileHost& aTile) {
for (size_t i = mFirstPossibility; i < mTiles.Length(); i++) {
// Skip over existing tiles without a retained texture source
@@ -220,19 +220,19 @@ public:
mFirstPossibility++;
}
continue;
}
// If this tile matches, then copy across the retained texture source (if
// any).
if (aTile.mTextureHost == mTiles[i].mTextureHost) {
- aTile.mTextureSource = Move(mTiles[i].mTextureSource);
+ aTile.mTextureSource = std::move(mTiles[i].mTextureSource);
if (aTile.mTextureHostOnWhite) {
- aTile.mTextureSourceOnWhite = Move(mTiles[i].mTextureSourceOnWhite);
+ aTile.mTextureSourceOnWhite = std::move(mTiles[i].mTextureSourceOnWhite);
}
break;
}
}
}
// Attempts to recycle any texture source to avoid needing to allocate
// a new one.
@@ -242,19 +242,19 @@ public:
if (i == mFirstPossibility) {
mFirstPossibility++;
}
continue;
}
if (mTiles[i].mTextureSource &&
mTiles[i].mTextureHost->GetFormat() == aTile.mTextureHost->GetFormat()) {
- aTile.mTextureSource = Move(mTiles[i].mTextureSource);
+ aTile.mTextureSource = std::move(mTiles[i].mTextureSource);
if (aTile.mTextureHostOnWhite) {
- aTile.mTextureSourceOnWhite = Move(mTiles[i].mTextureSourceOnWhite);
+ aTile.mTextureSourceOnWhite = std::move(mTiles[i].mTextureSourceOnWhite);
}
break;
}
}
}
void RecycleTileFading(TileHost& aTile) {
for (size_t i = 0; i < mTiles.Length(); i++) {
@@ -290,17 +290,17 @@ TiledLayerBufferComposite::UseTiles(cons
return false;
}
TilesPlacement newTiles(aTiles.firstTileX(), aTiles.firstTileY(),
aTiles.retainedWidth(), aTiles.retainedHeight());
const InfallibleTArray<TileDescriptor>& tileDescriptors = aTiles.tiles();
- TextureSourceRecycler oldRetainedTiles(Move(mRetainedTiles));
+ TextureSourceRecycler oldRetainedTiles(std::move(mRetainedTiles));
mRetainedTiles.SetLength(tileDescriptors.Length());
// Step 1, deserialize the incoming set of tiles into mRetainedTiles, and attempt
// to recycle the TextureSource for any repeated tiles.
//
// Since we don't have any retained 'tile' object, we have to search for instances
// of the same TextureHost in the old tile set. The cost of binding a TextureHost
// to a TextureSource for gralloc (binding EGLImage to GL texture) can be really
--- a/gfx/layers/d3d11/TextureD3D11.cpp
+++ b/gfx/layers/d3d11/TextureD3D11.cpp
@@ -416,28 +416,28 @@ DXGITextureData::SerializeSpecific(Surfa
bool
DXGITextureData::Serialize(SurfaceDescriptor& aOutDescriptor)
{
SurfaceDescriptorD3D10 desc;
if (!SerializeSpecific(&desc))
return false;
- aOutDescriptor = Move(desc);
+ aOutDescriptor = std::move(desc);
return true;
}
void
DXGITextureData::GetSubDescriptor(GPUVideoSubDescriptor* const aOutDesc)
{
SurfaceDescriptorD3D10 ret;
if (!SerializeSpecific(&ret))
return;
- *aOutDesc = Move(ret);
+ *aOutDesc = std::move(ret);
}
DXGITextureData*
DXGITextureData::Create(IntSize aSize, SurfaceFormat aFormat, TextureAllocationFlags aFlags)
{
if (aFormat == SurfaceFormat::A8) {
// Currently we don't support A8 surfaces. Fallback.
return nullptr;
@@ -726,27 +726,27 @@ DXGIYCbCrTextureData::SerializeSpecific(
}
bool
DXGIYCbCrTextureData::Serialize(SurfaceDescriptor& aOutDescriptor)
{
SurfaceDescriptorDXGIYCbCr desc;
SerializeSpecific(&desc);
- aOutDescriptor = Move(desc);
+ aOutDescriptor = std::move(desc);
return true;
}
void
DXGIYCbCrTextureData::GetSubDescriptor(GPUVideoSubDescriptor* const aOutDesc)
{
SurfaceDescriptorDXGIYCbCr desc;
SerializeSpecific(&desc);
- *aOutDesc = Move(desc);
+ *aOutDesc = std::move(desc);
}
void
DXGIYCbCrTextureData::Deallocate(LayersIPCChannel*)
{
mD3D9Textures[0] = nullptr;
mD3D9Textures[1] = nullptr;
mD3D9Textures[2] = nullptr;
--- a/gfx/layers/ipc/APZCTreeManagerParent.cpp
+++ b/gfx/layers/ipc/APZCTreeManagerParent.cpp
@@ -12,18 +12,18 @@
namespace mozilla {
namespace layers {
APZCTreeManagerParent::APZCTreeManagerParent(LayersId aLayersId,
RefPtr<APZCTreeManager> aAPZCTreeManager,
RefPtr<APZUpdater> aAPZUpdater)
: mLayersId(aLayersId)
- , mTreeManager(Move(aAPZCTreeManager))
- , mUpdater(Move(aAPZUpdater))
+ , mTreeManager(std::move(aAPZCTreeManager))
+ , mUpdater(std::move(aAPZUpdater))
{
MOZ_ASSERT(mTreeManager != nullptr);
MOZ_ASSERT(mUpdater != nullptr);
MOZ_ASSERT(mUpdater->HasTreeManager(mTreeManager));
}
APZCTreeManagerParent::~APZCTreeManagerParent()
{
@@ -31,18 +31,18 @@ APZCTreeManagerParent::~APZCTreeManagerP
void
APZCTreeManagerParent::ChildAdopted(RefPtr<APZCTreeManager> aAPZCTreeManager,
RefPtr<APZUpdater> aAPZUpdater)
{
MOZ_ASSERT(aAPZCTreeManager != nullptr);
MOZ_ASSERT(aAPZUpdater != nullptr);
MOZ_ASSERT(aAPZUpdater->HasTreeManager(aAPZCTreeManager));
- mTreeManager = Move(aAPZCTreeManager);
- mUpdater = Move(aAPZUpdater);
+ mTreeManager = std::move(aAPZCTreeManager);
+ mUpdater = std::move(aAPZUpdater);
}
mozilla::ipc::IPCResult
APZCTreeManagerParent::RecvSetKeyboardMap(const KeyboardMap& aKeyboardMap)
{
mUpdater->RunOnControllerThread(mLayersId, NewRunnableMethod<KeyboardMap>(
"layers::IAPZCTreeManager::SetKeyboardMap",
mTreeManager,
@@ -148,17 +148,17 @@ APZCTreeManagerParent::RecvSetAllowedTou
mUpdater->RunOnControllerThread(
mLayersId,
NewRunnableMethod<uint64_t,
StoreCopyPassByRRef<nsTArray<TouchBehaviorFlags>>>(
"layers::IAPZCTreeManager::SetAllowedTouchBehavior",
mTreeManager,
&IAPZCTreeManager::SetAllowedTouchBehavior,
aInputBlockId,
- Move(aValues)));
+ std::move(aValues)));
return IPC_OK();
}
mozilla::ipc::IPCResult
APZCTreeManagerParent::RecvStartScrollbarDrag(
const ScrollableLayerGuid& aGuid,
const AsyncDragMetrics& aDragMetrics)
--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
@@ -853,19 +853,19 @@ CompositorBridgeParent::ScheduleResumeOn
return !mPaused;
}
void
CompositorBridgeParent::ScheduleTask(already_AddRefed<CancelableRunnable> task, int time)
{
if (time == 0) {
- MessageLoop::current()->PostTask(Move(task));
+ MessageLoop::current()->PostTask(std::move(task));
} else {
- MessageLoop::current()->PostDelayedTask(Move(task), time);
+ MessageLoop::current()->PostDelayedTask(std::move(task), time);
}
}
void
CompositorBridgeParent::UpdatePaintTime(LayerTransactionParent* aLayerTree,
const TimeDuration& aPaintTime)
{
// We get a lot of paint timings for things with empty transactions.
@@ -1847,31 +1847,31 @@ CompositorBridgeParent::AllocPWebRenderB
// before the updater thread is created in WebRenderAPI::Create, so
// that the callback from the updater thread can find the right APZUpdater.
mApzUpdater->SetWebRenderWindowId(windowId);
}
if (mApzSampler) {
// Same as for mApzUpdater, but for the sampler thread.
mApzSampler->SetWebRenderWindowId(windowId);
}
- RefPtr<wr::WebRenderAPI> api = wr::WebRenderAPI::Create(this, Move(widget), windowId, aSize);
+ RefPtr<wr::WebRenderAPI> api = wr::WebRenderAPI::Create(this, std::move(widget), windowId, aSize);
if (!api) {
mWrBridge = WebRenderBridgeParent::CreateDestroyed(aPipelineId);
mWrBridge.get()->AddRef(); // IPDL reference
*aIdNamespace = mWrBridge->GetIdNamespace();
*aTextureFactoryIdentifier = TextureFactoryIdentifier(LayersBackend::LAYERS_NONE);
return mWrBridge;
}
mAsyncImageManager = new AsyncImagePipelineManager(api->Clone());
RefPtr<AsyncImagePipelineManager> asyncMgr = mAsyncImageManager;
wr::TransactionBuilder txn;
txn.SetRootPipeline(aPipelineId);
api->SendTransaction(txn);
RefPtr<CompositorAnimationStorage> animStorage = GetAnimationStorage();
- mWrBridge = new WebRenderBridgeParent(this, aPipelineId, mWidget, nullptr, Move(api), Move(asyncMgr), Move(animStorage));
+ mWrBridge = new WebRenderBridgeParent(this, aPipelineId, mWidget, nullptr, std::move(api), std::move(asyncMgr), std::move(animStorage));
mWrBridge.get()->AddRef(); // IPDL reference
*aIdNamespace = mWrBridge->GetIdNamespace();
mCompositorScheduler = mWrBridge->CompositorScheduler();
MOZ_ASSERT(mCompositorScheduler);
{ // scope lock
MonitorAutoLock lock(*sIndirectLayerTreesLock);
MOZ_ASSERT(sIndirectLayerTrees[mRootLayerTreeID].mWrBridge == nullptr);
--- a/gfx/layers/ipc/CompositorManagerChild.cpp
+++ b/gfx/layers/ipc/CompositorManagerChild.cpp
@@ -60,17 +60,17 @@ CompositorManagerChild::Init(Endpoint<PC
uint32_t aNamespace,
uint64_t aProcessToken /* = 0 */)
{
MOZ_ASSERT(NS_IsMainThread());
if (sInstance) {
MOZ_ASSERT(sInstance->mNamespace != aNamespace);
}
- sInstance = new CompositorManagerChild(Move(aEndpoint), aProcessToken,
+ sInstance = new CompositorManagerChild(std::move(aEndpoint), aProcessToken,
aNamespace);
return sInstance->CanSend();
}
/* static */ void
CompositorManagerChild::Shutdown()
{
MOZ_ASSERT(NS_IsMainThread());
--- a/gfx/layers/ipc/CompositorManagerParent.cpp
+++ b/gfx/layers/ipc/CompositorManagerParent.cpp
@@ -56,17 +56,17 @@ CompositorManagerParent::Create(Endpoint
MOZ_ASSERT(aEndpoint.OtherPid() != base::GetCurrentProcId());
RefPtr<CompositorManagerParent> bridge = new CompositorManagerParent();
RefPtr<Runnable> runnable = NewRunnableMethod<Endpoint<PCompositorManagerParent>&&>(
"CompositorManagerParent::Bind",
bridge,
&CompositorManagerParent::Bind,
- Move(aEndpoint));
+ std::move(aEndpoint));
CompositorThreadHolder::Loop()->PostTask(runnable.forget());
}
/* static */ already_AddRefed<CompositorBridgeParent>
CompositorManagerParent::CreateSameProcessWidgetCompositorBridge(CSSToLayoutDeviceScale aScale,
const CompositorOptions& aOptions,
bool aUseExternalSurfaceSize,
const gfx::IntSize& aSurfaceSize)
--- a/gfx/layers/ipc/CompositorVsyncScheduler.cpp
+++ b/gfx/layers/ipc/CompositorVsyncScheduler.cpp
@@ -139,17 +139,17 @@ CompositorVsyncScheduler::PostVRTask(Tim
MonitorAutoLock lockVR(mCurrentVRListenerTaskMonitor);
if (mCurrentVRListenerTask == nullptr && VRListenerThreadHolder::Loop()) {
RefPtr<Runnable> task = NewRunnableMethod<TimeStamp>(
"layers::CompositorVsyncScheduler::DispatchVREvents",
this,
&CompositorVsyncScheduler::DispatchVREvents,
aTimestamp);
mCurrentVRListenerTask = task;
- VRListenerThreadHolder::Loop()->PostDelayedTask(Move(task.forget()), 0);
+ VRListenerThreadHolder::Loop()->PostDelayedTask(std::move(task.forget()), 0);
}
}
void
CompositorVsyncScheduler::ScheduleComposition()
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
if (!mVsyncObserver) {
@@ -331,17 +331,17 @@ CompositorVsyncScheduler::DispatchVREven
VRManager* vm = VRManager::Get();
vm->NotifyVsync(aVsyncTimestamp);
}
void
CompositorVsyncScheduler::ScheduleTask(already_AddRefed<CancelableRunnable> aTask)
{
MOZ_ASSERT(CompositorThreadHolder::Loop());
- CompositorThreadHolder::Loop()->PostDelayedTask(Move(aTask), 0);
+ CompositorThreadHolder::Loop()->PostDelayedTask(std::move(aTask), 0);
}
const TimeStamp&
CompositorVsyncScheduler::GetLastComposeTime() const
{
MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
return mLastCompose;
}
--- a/gfx/layers/ipc/CrossProcessCompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CrossProcessCompositorBridgeParent.cpp
@@ -238,17 +238,17 @@ CrossProcessCompositorBridgeParent::Allo
*aTextureFactoryIdentifier = TextureFactoryIdentifier(LayersBackend::LAYERS_NONE);
return parent;
}
api = api->Clone();
RefPtr<AsyncImagePipelineManager> holder = root->AsyncImageManager();
RefPtr<CompositorAnimationStorage> animStorage = cbp->GetAnimationStorage();
WebRenderBridgeParent* parent = new WebRenderBridgeParent(
- this, aPipelineId, nullptr, root->CompositorScheduler(), Move(api), Move(holder), Move(animStorage));
+ this, aPipelineId, nullptr, root->CompositorScheduler(), std::move(api), std::move(holder), std::move(animStorage));
parent->AddRef(); // IPDL reference
{ // scope lock
MonitorAutoLock lock(*sIndirectLayerTreesLock);
sIndirectLayerTrees[layersId].mCrossProcessParent = this;
sIndirectLayerTrees[layersId].mWrBridge = parent;
}
*aTextureFactoryIdentifier = parent->GetTextureFactoryIdentifier();
--- a/gfx/layers/ipc/ImageBridgeChild.cpp
+++ b/gfx/layers/ipc/ImageBridgeChild.cpp
@@ -510,17 +510,17 @@ ImageBridgeChild::InitForContent(Endpoin
}
RefPtr<ImageBridgeChild> child = new ImageBridgeChild(aNamespace);
RefPtr<Runnable> runnable = NewRunnableMethod<Endpoint<PImageBridgeChild>&&>(
"layers::ImageBridgeChild::Bind",
child,
&ImageBridgeChild::Bind,
- Move(aEndpoint));
+ std::move(aEndpoint));
child->GetMessageLoop()->PostTask(runnable.forget());
// Assign this after so other threads can't post messages before we connect to IPDL.
{
StaticMutexAutoLock lock(sImageBridgeSingletonLock);
sImageBridgeChildSingleton = child;
}
@@ -533,17 +533,17 @@ ImageBridgeChild::ReinitForContent(Endpo
MOZ_ASSERT(NS_IsMainThread());
// Note that at this point, ActorDestroy may not have been called yet,
// meaning mCanSend is still true. In this case we will try to send a
// synchronous WillClose message to the parent, and will certainly get a
// false result and a MsgDropped processing error. This is okay.
ShutdownSingleton();
- return InitForContent(Move(aEndpoint), aNamespace);
+ return InitForContent(std::move(aEndpoint), aNamespace);
}
void
ImageBridgeChild::Bind(Endpoint<PImageBridgeChild>&& aEndpoint)
{
if (!aEndpoint.Bind(this)) {
return;
}
@@ -662,17 +662,17 @@ ImageBridgeChild::InitWithGPUProcess(End
RefPtr<ImageBridgeChild> child = new ImageBridgeChild(aNamespace);
MessageLoop* loop = child->GetMessageLoop();
loop->PostTask(NewRunnableMethod<Endpoint<PImageBridgeChild>&&>(
"layers::ImageBridgeChild::Bind",
child,
&ImageBridgeChild::Bind,
- Move(aEndpoint)));
+ std::move(aEndpoint)));
// Assign this after so other threads can't post messages before we connect to IPDL.
{
StaticMutexAutoLock lock(sImageBridgeSingletonLock);
sImageBridgeChildSingleton = child;
}
}
--- a/gfx/layers/ipc/ImageBridgeParent.cpp
+++ b/gfx/layers/ipc/ImageBridgeParent.cpp
@@ -100,17 +100,17 @@ ImageBridgeParent::CreateForGPUProcess(E
MessageLoop* loop = CompositorThreadHolder::Loop();
RefPtr<ImageBridgeParent> parent = new ImageBridgeParent(loop, aEndpoint.OtherPid());
loop->PostTask(NewRunnableMethod<Endpoint<PImageBridgeParent>&&>(
"layers::ImageBridgeParent::Bind",
parent,
&ImageBridgeParent::Bind,
- Move(aEndpoint)));
+ std::move(aEndpoint)));
sImageBridgeParentSingleton = parent;
return true;
}
/* static */ void
ImageBridgeParent::ShutdownInternal()
{
@@ -219,17 +219,17 @@ ImageBridgeParent::CreateForContent(Endp
{
MessageLoop* loop = CompositorThreadHolder::Loop();
RefPtr<ImageBridgeParent> bridge = new ImageBridgeParent(loop, aEndpoint.OtherPid());
loop->PostTask(NewRunnableMethod<Endpoint<PImageBridgeParent>&&>(
"layers::ImageBridgeParent::Bind",
bridge,
&ImageBridgeParent::Bind,
- Move(aEndpoint)));
+ std::move(aEndpoint)));
return true;
}
void
ImageBridgeParent::Bind(Endpoint<PImageBridgeParent>&& aEndpoint)
{
if (!aEndpoint.Bind(this))
--- a/gfx/layers/ipc/LayersMessageUtils.h
+++ b/gfx/layers/ipc/LayersMessageUtils.h
@@ -564,17 +564,17 @@ struct ParamTraits<mozilla::layers::Keyb
}
static bool Read(const Message* aMsg, PickleIterator* aIter, paramType* aResult)
{
nsTArray<mozilla::layers::KeyboardShortcut> shortcuts;
if (!ReadParam(aMsg, aIter, &shortcuts)) {
return false;
}
- *aResult = mozilla::layers::KeyboardMap(mozilla::Move(shortcuts));
+ *aResult = mozilla::layers::KeyboardMap(std::move(shortcuts));
return true;
}
};
typedef mozilla::layers::GeckoContentController GeckoContentController;
typedef GeckoContentController::TapType TapType;
template <>
--- a/gfx/layers/ipc/RemoteContentController.cpp
+++ b/gfx/layers/ipc/RemoteContentController.cpp
@@ -194,29 +194,29 @@ RemoteContentController::NotifyPinchGest
}
}
}
void
RemoteContentController::PostDelayedTask(already_AddRefed<Runnable> aTask, int aDelayMs)
{
(MessageLoop::current() ? MessageLoop::current() : mCompositorThread)->
- PostDelayedTask(Move(aTask), aDelayMs);
+ PostDelayedTask(std::move(aTask), aDelayMs);
}
bool
RemoteContentController::IsRepaintThread()
{
return MessageLoop::current() == mCompositorThread;
}
void
RemoteContentController::DispatchToRepaintThread(already_AddRefed<Runnable> aTask)
{
- mCompositorThread->PostTask(Move(aTask));
+ mCompositorThread->PostTask(std::move(aTask));
}
void
RemoteContentController::NotifyAPZStateChange(const ScrollableLayerGuid& aGuid,
APZStateChange aChange,
int aArg)
{
if (MessageLoop::current() != mCompositorThread) {
--- a/gfx/layers/ipc/ShadowLayers.cpp
+++ b/gfx/layers/ipc/ShadowLayers.cpp
@@ -230,17 +230,17 @@ ShadowLayerForwarder::ShadowLayerForward
template<typename T>
struct ReleaseOnMainThreadTask : public Runnable
{
UniquePtr<T> mObj;
explicit ReleaseOnMainThreadTask(UniquePtr<T>& aObj)
: Runnable("layers::ReleaseOnMainThreadTask")
- , mObj(Move(aObj))
+ , mObj(std::move(aObj))
{}
NS_IMETHOD Run() override {
mObj = nullptr;
return NS_OK;
}
};
@@ -727,20 +727,20 @@ ShadowLayerForwarder::EndTransaction(con
setAttrs.IsEmpty() &&
!mTxn->RotationChanged())
{
return true;
}
mWindowOverlayChanged = false;
- info.cset() = Move(mTxn->mCset);
- info.setSimpleAttrs() = Move(setSimpleAttrs);
- info.setAttrs() = Move(setAttrs);
- info.paints() = Move(mTxn->mPaints);
+ info.cset() = std::move(mTxn->mCset);
+ info.setSimpleAttrs() = std::move(setSimpleAttrs);
+ info.setAttrs() = std::move(setAttrs);
+ info.paints() = std::move(mTxn->mPaints);
info.toDestroy() = mTxn->mDestroyedActors;
info.fwdTransactionId() = GetFwdTransactionId();
info.id() = aId;
info.plugins() = mPluginWindowData;
info.isFirstPaint() = mIsFirstPaint;
info.focusTarget() = mFocusTarget;
info.scheduleComposite() = aScheduleComposite;
info.paintSequenceNumber() = aPaintSequenceNumber;
--- a/gfx/layers/ipc/SharedSurfacesChild.cpp
+++ b/gfx/layers/ipc/SharedSurfacesChild.cpp
@@ -26,24 +26,24 @@ public:
const wr::ImageKey& aImageKey,
int32_t aInvalidations)
: mManager(aManager)
, mImageKey(aImageKey)
, mInvalidations(aInvalidations)
{ }
ImageKeyData(ImageKeyData&& aOther)
- : mManager(Move(aOther.mManager))
+ : mManager(std::move(aOther.mManager))
, mImageKey(aOther.mImageKey)
, mInvalidations(aOther.mInvalidations)
{ }
ImageKeyData& operator=(ImageKeyData&& aOther)
{
- mManager = Move(aOther.mManager);
+ mManager = std::move(aOther.mManager);
mImageKey = aOther.mImageKey;
mInvalidations = aOther.mInvalidations;
return *this;
}
ImageKeyData(const ImageKeyData&) = delete;
ImageKeyData& operator=(const ImageKeyData&) = delete;
@@ -69,31 +69,31 @@ public:
} else {
class DestroyRunnable final : public Runnable
{
public:
DestroyRunnable(const wr::ExternalImageId& aId,
nsTArray<ImageKeyData>&& aKeys)
: Runnable("SharedSurfacesChild::SharedUserData::DestroyRunnable")
, mId(aId)
- , mKeys(Move(aKeys))
+ , mKeys(std::move(aKeys))
{ }
NS_IMETHOD Run() override
{
SharedSurfacesChild::Unshare(mId, mKeys);
return NS_OK;
}
private:
wr::ExternalImageId mId;
AutoTArray<ImageKeyData, 1> mKeys;
};
- nsCOMPtr<nsIRunnable> task = new DestroyRunnable(mId, Move(mKeys));
+ nsCOMPtr<nsIRunnable> task = new DestroyRunnable(mId, std::move(mKeys));
SystemGroup::Dispatch(TaskCategory::Other, task.forget());
}
}
}
const wr::ExternalImageId& Id() const
{
return mId;
@@ -158,17 +158,17 @@ public:
key = entry.mImageKey;
found = true;
}
}
if (!found) {
key = aManager->WrBridge()->GetNextImageKey();
ImageKeyData data(aManager, key, aInvalidations);
- mKeys.AppendElement(Move(data));
+ mKeys.AppendElement(std::move(data));
aResources.AddExternalImage(mId, key);
}
return key;
}
private:
AutoTArray<ImageKeyData, 1> mKeys;
--- a/gfx/layers/ipc/UiCompositorControllerChild.cpp
+++ b/gfx/layers/ipc/UiCompositorControllerChild.cpp
@@ -62,17 +62,17 @@ UiCompositorControllerChild::CreateForGP
{
RefPtr<UiCompositorControllerChild> child = new UiCompositorControllerChild(aProcessToken);
RefPtr<nsIRunnable> task =
NewRunnableMethod<Endpoint<PUiCompositorControllerChild>&&>(
"layers::UiCompositorControllerChild::OpenForGPUProcess",
child,
&UiCompositorControllerChild::OpenForGPUProcess,
- Move(aEndpoint));
+ std::move(aEndpoint));
GetUiThread()->Dispatch(task.forget(), nsIThread::DISPATCH_NORMAL);
return child;
}
bool
UiCompositorControllerChild::Pause()
{
@@ -286,17 +286,17 @@ UiCompositorControllerChild::RecvRootFra
return IPC_OK();
}
mozilla::ipc::IPCResult
UiCompositorControllerChild::RecvScreenPixels(ipc::Shmem&& aMem, const ScreenIntSize& aSize)
{
#if defined(MOZ_WIDGET_ANDROID)
if (mWidget) {
- mWidget->RecvScreenPixels(Move(aMem), aSize);
+ mWidget->RecvScreenPixels(std::move(aMem), aSize);
}
#endif // defined(MOZ_WIDGET_ANDROID)
return IPC_OK();
}
// private:
UiCompositorControllerChild::UiCompositorControllerChild(const uint64_t& aProcessToken)
--- a/gfx/layers/ipc/UiCompositorControllerParent.cpp
+++ b/gfx/layers/ipc/UiCompositorControllerParent.cpp
@@ -24,30 +24,30 @@ typedef CompositorBridgeParent::LayerTre
/* static */ RefPtr<UiCompositorControllerParent>
UiCompositorControllerParent::GetFromRootLayerTreeId(const LayersId& aRootLayerTreeId)
{
RefPtr<UiCompositorControllerParent> controller;
CompositorBridgeParent::CallWithIndirectShadowTree(aRootLayerTreeId,
[&](LayerTreeState& aState) -> void {
controller = aState.mUiControllerParent;
});
- return Move(controller);
+ return std::move(controller);
}
/* static */ RefPtr<UiCompositorControllerParent>
UiCompositorControllerParent::Start(const LayersId& aRootLayerTreeId, Endpoint<PUiCompositorControllerParent>&& aEndpoint)
{
RefPtr<UiCompositorControllerParent> parent = new UiCompositorControllerParent(aRootLayerTreeId);
RefPtr<Runnable> task =
NewRunnableMethod<Endpoint<PUiCompositorControllerParent>&&>(
"layers::UiCompositorControllerParent::Open",
parent,
&UiCompositorControllerParent::Open,
- Move(aEndpoint));
+ std::move(aEndpoint));
CompositorThreadHolder::Loop()->PostTask(task.forget());
return parent;
}
mozilla::ipc::IPCResult
UiCompositorControllerParent::RecvPause()
{
@@ -172,17 +172,17 @@ UiCompositorControllerParent::RecvEnable
}
mozilla::ipc::IPCResult
UiCompositorControllerParent::RecvToolbarPixelsToCompositor(Shmem&& aMem, const ScreenIntSize& aSize)
{
#if defined(MOZ_WIDGET_ANDROID)
if (mAnimator) {
// By adopting the Shmem, the animator is responsible for deallocating.
- mAnimator->AdoptToolbarPixels(Move(aMem), aSize);
+ mAnimator->AdoptToolbarPixels(std::move(aMem), aSize);
} else {
DeallocShmem(aMem);
}
#endif // defined(MOZ_WIDGET_ANDROID)
return IPC_OK();
}
--- a/gfx/layers/mlgpu/BufferCache.h
+++ b/gfx/layers/mlgpu/BufferCache.h
@@ -54,17 +54,17 @@ private:
CacheEntry() : mLastUsedFrame(0)
{}
CacheEntry(const CacheEntry& aEntry)
: mLastUsedFrame(aEntry.mLastUsedFrame),
mBuffer(aEntry.mBuffer)
{}
CacheEntry(CacheEntry&& aEntry)
: mLastUsedFrame(aEntry.mLastUsedFrame),
- mBuffer(Move(aEntry.mBuffer))
+ mBuffer(std::move(aEntry.mBuffer))
{}
CacheEntry(size_t aLastUsedFrame, MLGBuffer* aBuffer)
: mLastUsedFrame(aLastUsedFrame),
mBuffer(aBuffer)
{}
uint64_t mLastUsedFrame;
RefPtr<MLGBuffer> mBuffer;
--- a/gfx/layers/mlgpu/CanvasLayerMLGPU.cpp
+++ b/gfx/layers/mlgpu/CanvasLayerMLGPU.cpp
@@ -94,13 +94,13 @@ CanvasLayerMLGPU::ClearCachedResources()
{
CleanupResources();
}
void
CanvasLayerMLGPU::SetRenderRegion(LayerIntRegion&& aRegion)
{
aRegion.AndWith(LayerIntRect::FromUnknownRect(mPictureRect));
- LayerMLGPU::SetRenderRegion(Move(aRegion));
+ LayerMLGPU::SetRenderRegion(std::move(aRegion));
}
} // namespace layers
} // namespace mozilla
--- a/gfx/layers/mlgpu/ContainerLayerMLGPU.cpp
+++ b/gfx/layers/mlgpu/ContainerLayerMLGPU.cpp
@@ -49,22 +49,22 @@ ContainerLayerMLGPU::OnPrepareToRender(F
if ((!mRenderTarget || mChildrenChanged) &&
gfxPrefs::AdvancedLayersEnableContainerResizing())
{
// Try to compute a more accurate visible region.
AL_LOG("Computing new surface size for container %p:\n", GetLayer());
Maybe<IntRect> bounds = ComputeIntermediateSurfaceBounds();
if (bounds) {
- LayerIntRegion region = Move(GetShadowVisibleRegion());
+ LayerIntRegion region = std::move(GetShadowVisibleRegion());
region.AndWith(LayerIntRect::FromUnknownRect(bounds.value()));
AL_LOG(" computed bounds: %s\n", Stringify(bounds.value()).c_str());
AL_LOG(" new visible: %s\n", Stringify(region).c_str());
- SetShadowVisibleRegion(Move(region));
+ SetShadowVisibleRegion(std::move(region));
}
}
mChildrenChanged = false;
mTargetOffset = GetIntermediateSurfaceRect().TopLeft().ToUnknownPoint();
mTargetSize = GetIntermediateSurfaceRect().Size().ToUnknownSize();
if (mRenderTarget && mRenderTarget->GetSize() != mTargetSize) {
--- a/gfx/layers/mlgpu/FrameBuilder.cpp
+++ b/gfx/layers/mlgpu/FrameBuilder.cpp
@@ -66,17 +66,17 @@ FrameBuilder::Build()
mWidgetRenderView = new RenderViewMLGPU(this, target, region);
// Traverse the layer tree and assign each layer to tiles.
{
Maybe<gfx::Polygon> geometry;
RenderTargetIntRect clip(0, 0, target->GetSize().width, target->GetSize().height);
- AssignLayer(mRoot->GetLayer(), mWidgetRenderView, clip, Move(geometry));
+ AssignLayer(mRoot->GetLayer(), mWidgetRenderView, clip, std::move(geometry));
}
// Build the default mask buffer.
{
MaskInformation defaultMaskInfo(1.0f, false);
if (!mDevice->GetSharedPSBuffer()->Allocate(&mDefaultMaskInfo, defaultMaskInfo)) {
return false;
}
@@ -134,17 +134,17 @@ FrameBuilder::AssignLayer(Layer* aLayer,
// If we are dealing with a nested 3D context, we might need to transform
// the geometry back to the coordinate space of the current layer.
if (aGeometry) {
TransformLayerGeometry(aLayer, aGeometry);
}
// Finally, assign the layer to a rendering batch in the current render
// target.
- layer->AssignToView(this, aView, Move(aGeometry));
+ layer->AssignToView(this, aView, std::move(aGeometry));
}
bool
FrameBuilder::ProcessContainerLayer(ContainerLayer* aContainer,
RenderViewMLGPU* aView,
const RenderTargetIntRect& aClipRect,
Maybe<gfx::Polygon>& aGeometry)
{
@@ -219,20 +219,20 @@ FrameBuilder::ProcessChildList(Container
Maybe<gfx::Polygon> geometry;
if (aParentGeometry && entry.geometry) {
// Both parent and child are split.
geometry = Some(aParentGeometry->ClipPolygon(*entry.geometry));
} else if (aParentGeometry) {
geometry = aParentGeometry;
} else if (entry.geometry) {
- geometry = Move(entry.geometry);
+ geometry = std::move(entry.geometry);
}
- AssignLayer(child, aView, clip, Move(geometry));
+ AssignLayer(child, aView, clip, std::move(geometry));
}
}
bool
FrameBuilder::AddLayerToConstantBuffer(ItemInfo& aItem)
{
LayerMLGPU* layer = aItem.layer;
--- a/gfx/layers/mlgpu/ImageLayerMLGPU.cpp
+++ b/gfx/layers/mlgpu/ImageLayerMLGPU.cpp
@@ -84,17 +84,17 @@ ImageLayerMLGPU::SetRenderRegion(LayerIn
aRegion.AndWith(LayerIntRect(0, 0, mScaleToSize.width, mScaleToSize.height));
break;
default:
// Clamp the visible region to the texture size. (see bug 1396507)
MOZ_ASSERT(mScaleMode == ScaleMode::SCALE_NONE);
aRegion.AndWith(LayerIntRect(0, 0, mPictureRect.Width(), mPictureRect.Height()));
break;
}
- LayerMLGPU::SetRenderRegion(Move(aRegion));
+ LayerMLGPU::SetRenderRegion(std::move(aRegion));
}
void
ImageLayerMLGPU::CleanupResources()
{
if (mHost) {
mHost->CleanupResources();
mHost->Detach(this);
--- a/gfx/layers/mlgpu/LayerMLGPU.cpp
+++ b/gfx/layers/mlgpu/LayerMLGPU.cpp
@@ -73,26 +73,26 @@ LayerMLGPU::PrepareToRender(FrameBuilder
return true;
}
void
LayerMLGPU::AssignToView(FrameBuilder* aBuilder,
RenderViewMLGPU* aView,
Maybe<gfx::Polygon>&& aGeometry)
{
- AddBoundsToView(aBuilder, aView, Move(aGeometry));
+ AddBoundsToView(aBuilder, aView, std::move(aGeometry));
}
void
LayerMLGPU::AddBoundsToView(FrameBuilder* aBuilder,
RenderViewMLGPU* aView,
Maybe<gfx::Polygon>&& aGeometry)
{
IntRect bounds = GetClippedBoundingBox(aView, aGeometry);
- aView->AddItem(this, bounds, Move(aGeometry));
+ aView->AddItem(this, bounds, std::move(aGeometry));
}
IntRect
LayerMLGPU::GetClippedBoundingBox(RenderViewMLGPU* aView,
const Maybe<gfx::Polygon>& aGeometry)
{
MOZ_ASSERT(IsPrepared());
@@ -123,17 +123,17 @@ bool
LayerMLGPU::IsContentOpaque()
{
return GetLayer()->IsOpaque();
}
void
LayerMLGPU::SetRenderRegion(LayerIntRegion&& aRegion)
{
- mRenderRegion = Move(aRegion);
+ mRenderRegion = std::move(aRegion);
}
void
LayerMLGPU::SetLayerManager(HostLayerManager* aManager)
{
LayerManagerMLGPU* manager = aManager->AsLayerManagerMLGPU();
MOZ_RELEASE_ASSERT(manager);
--- a/gfx/layers/mlgpu/LayerManagerMLGPU.cpp
+++ b/gfx/layers/mlgpu/LayerManagerMLGPU.cpp
@@ -298,17 +298,17 @@ LayerManagerMLGPU::Composite()
kDebugOverlayX, kDebugOverlayY,
kDebugOverlayMaxWidth, kDebugOverlayMaxHeight));
}
AL_LOG("Computed invalid region: %s\n", Stringify(mInvalidRegion).c_str());
// Now that we have the final invalid region, give it to the swap chain which
// will tell us if we still need to render.
- if (!mSwapChain->ApplyNewInvalidRegion(Move(mInvalidRegion), diagnosticRect)) {
+ if (!mSwapChain->ApplyNewInvalidRegion(std::move(mInvalidRegion), diagnosticRect)) {
return;
}
AutoUnlockAllTextures autoUnlock(mDevice);
mDevice->BeginFrame();
RenderLayers();
@@ -478,17 +478,17 @@ LayerManagerMLGPU::ComputeInvalidRegion(
}
// We compute the change region, but if we're painting to a target, we save
// it for the next frame instead.
if (mTarget) {
mInvalidRegion = mTargetRect;
mNextFrameInvalidRegion.OrWith(changed);
} else {
- mInvalidRegion = Move(mNextFrameInvalidRegion);
+ mInvalidRegion = std::move(mNextFrameInvalidRegion);
mInvalidRegion.OrWith(changed);
}
}
void
LayerManagerMLGPU::AddInvalidRegion(const nsIntRegion& aRegion)
{
mNextFrameInvalidRegion.OrWith(aRegion);
--- a/gfx/layers/mlgpu/MLGDevice.cpp
+++ b/gfx/layers/mlgpu/MLGDevice.cpp
@@ -34,17 +34,17 @@ MLGSwapChain::MLGSwapChain()
}
bool
MLGSwapChain::ApplyNewInvalidRegion(nsIntRegion&& aRegion, const Maybe<gfx::IntRect>& aExtraRect)
{
// We clamp the invalid region to the backbuffer size, otherwise the present
// can fail.
IntRect bounds(IntPoint(0, 0), GetSize());
- nsIntRegion invalid = Move(aRegion);
+ nsIntRegion invalid = std::move(aRegion);
invalid.AndWith(bounds);
if (invalid.IsEmpty()) {
return false;
}
if (aExtraRect) {
IntRect rect = aExtraRect.value().Intersect(bounds);
if (!rect.IsEmpty()) {
@@ -300,17 +300,17 @@ MLGDevice::Synchronize()
}
void
MLGDevice::PrepareClearRegion(ClearRegionHelper* aOut,
nsTArray<gfx::IntRect>&& aRects,
const Maybe<int32_t>& aSortIndex)
{
if (CanUseClearView() && !aSortIndex) {
- aOut->mRects = Move(aRects);
+ aOut->mRects = std::move(aRects);
return;
}
mSharedVertexBuffer->Allocate(
&aOut->mInput,
aRects.Length(),
sizeof(IntRect),
aRects.Elements());
--- a/gfx/layers/mlgpu/PaintedLayerMLGPU.cpp
+++ b/gfx/layers/mlgpu/PaintedLayerMLGPU.cpp
@@ -38,17 +38,17 @@ PaintedLayerMLGPU::OnPrepareToRender(Fra
mTexture = nullptr;
mTextureOnWhite = nullptr;
return !!mHost;
}
void
PaintedLayerMLGPU::SetRenderRegion(LayerIntRegion&& aRegion)
{
- mRenderRegion = Move(aRegion);
+ mRenderRegion = std::move(aRegion);
LayerIntRect bounds(mRenderRegion.GetBounds().TopLeft(),
ViewAs<LayerPixel>(mTexture->GetSize()));
mRenderRegion.AndWith(bounds);
}
const LayerIntRegion&
PaintedLayerMLGPU::GetDrawRects()
@@ -121,17 +121,17 @@ PaintedLayerMLGPU::AssignToView(FrameBui
if (!mTexture) {
return;
}
mTextureOnWhite = single->AcquireTextureSourceOnWhite();
mDestOrigin = single->GetOriginOffset();
}
// Fall through to the single texture case.
- LayerMLGPU::AssignToView(aBuilder, aView, Move(aGeometry));
+ LayerMLGPU::AssignToView(aBuilder, aView, std::move(aGeometry));
}
void
PaintedLayerMLGPU::AssignHighResTilesToView(FrameBuilder* aBuilder,
RenderViewMLGPU* aView,
TiledContentHost* aTileHost,
const Maybe<Polygon>& aGeometry)
{
@@ -196,22 +196,22 @@ PaintedLayerMLGPU::AssignTileBufferToVie
mDestOrigin = offset;
// Yes, it's a bit weird that we're assigning the same layer to the same
// view multiple times. Note that each time, the texture, computed
// opacity, origin, and visible region are updated to match the current
// tile, and we restore these properties after we've finished processing
// all tiles.
Maybe<Polygon> geometry = aGeometry;
- LayerMLGPU::AssignToView(aBuilder, aView, Move(geometry));
+ LayerMLGPU::AssignToView(aBuilder, aView, std::move(geometry));
}
// Restore the computed opacity and visible region.
mComputedOpacity = baseOpacity;
- SetShadowVisibleRegion(Move(visible));
+ SetShadowVisibleRegion(std::move(visible));
}
void
PaintedLayerMLGPU::CleanupResources()
{
if (mHost) {
mHost->Detach(this);
}
--- a/gfx/layers/mlgpu/RenderPassMLGPU.cpp
+++ b/gfx/layers/mlgpu/RenderPassMLGPU.cpp
@@ -32,17 +32,17 @@ ItemInfo::ItemInfo(FrameBuilder* aBuilde
const IntRect& aBounds,
Maybe<Polygon>&& aGeometry)
: view(aView),
layer(aLayer),
type(RenderPassType::Unknown),
layerIndex(kInvalidResourceIndex),
sortOrder(aSortOrder),
bounds(aBounds),
- geometry(Move(aGeometry))
+ geometry(std::move(aGeometry))
{
const Matrix4x4& transform = aLayer->GetLayer()->GetEffectiveTransform();
Matrix transform2D;
if (!geometry &&
transform.Is2D(&transform2D) &&
transform2D.IsRectilinear())
{
--- a/gfx/layers/mlgpu/RenderViewMLGPU.cpp
+++ b/gfx/layers/mlgpu/RenderViewMLGPU.cpp
@@ -178,17 +178,17 @@ RenderViewMLGPU::AddItem(LayerMLGPU* aIt
//
// Sort order starts at 1 and goes to positive infinity, with smaller values
// being closer to the screen. Our viewport is the same, with anything
// outside of [0.0, 1.0] being culled, and lower values occluding higher
// values. To make this work our projection transform scales the z-axis.
// Note that we do not use 0 as a sorting index (when depth-testing is
// enabled) because this would result in a z-value of 1.0, which would be
// culled.
- ItemInfo info(mBuilder, this, aItem, mNextSortIndex++, aRect, Move(aGeometry));
+ ItemInfo info(mBuilder, this, aItem, mNextSortIndex++, aRect, std::move(aGeometry));
// If the item is not visible, or we can't add it to the layer constant
// buffer for some reason, bail out.
if (!UpdateVisibleRegion(info) || !mBuilder->AddLayerToConstantBuffer(info)) {
AL_LOG("RenderView %p culled item %p!\n", this, aItem->GetLayer());
return;
}
@@ -212,17 +212,17 @@ RenderViewMLGPU::UpdateVisibleRegion(Ite
if (mUseDepthBuffer ||
!aItem.translation ||
!gfxPrefs::AdvancedLayersEnableCPUOcclusion())
{
// Update the render region even if we won't compute visibility, since some
// layer types (like Canvas and Image) need to have the visible region
// clamped.
LayerIntRegion region = aItem.layer->GetShadowVisibleRegion();
- aItem.layer->SetRenderRegion(Move(region));
+ aItem.layer->SetRenderRegion(std::move(region));
AL_LOG("RenderView %p simple occlusion test, bounds=%s, translation?=%d\n",
this,
Stringify(aItem.bounds).c_str(),
aItem.translation ? 1 : 0);
return mInvalidBounds.Intersects(aItem.bounds);
}
@@ -249,17 +249,17 @@ RenderViewMLGPU::UpdateVisibleRegion(Ite
if (region.IsEmpty()) {
return false;
}
// Move the visible region back into layer space.
region.MoveBy(-translation);
AL_LOG(" new-local-visible=%s\n", Stringify(region).c_str());
- aItem.layer->SetRenderRegion(Move(region));
+ aItem.layer->SetRenderRegion(std::move(region));
// Apply the new occluded area. We do another dance with the translation to
// avoid copying the region. We do this after the SetRegionToRender call to
// accomodate the possiblity of a layer changing its visible region.
if (aItem.opaque) {
mOccludedRegion.MoveBy(-translation);
mOccludedRegion.OrWith(aItem.layer->GetRenderRegion());
mOccludedRegion.MoveBy(translation);
@@ -571,23 +571,23 @@ RenderViewMLGPU::PrepareClears()
Maybe<int32_t> sortIndex;
if (mUseDepthBuffer) {
// Note that we use the lowest available sorting index, to ensure that when
// using the z-buffer, we don't draw over already-drawn content.
sortIndex = Some(mNextSortIndex++);
}
nsTArray<IntRect> rects = ToRectArray(region);
- mDevice->PrepareClearRegion(&mPreClear, Move(rects), sortIndex);
+ mDevice->PrepareClearRegion(&mPreClear, std::move(rects), sortIndex);
if (!mPostClearRegion.IsEmpty()) {
// Prepare the final clear as well. Note that we always do this clear at the
// very end, even when the depth buffer is enabled, so we don't bother
// setting a useful sorting index. If and when we try to ship the depth
// buffer, we would execute this clear earlier in the pipeline and give it
// the closest possible z-ordering to the screen.
nsTArray<IntRect> rects = ToRectArray(mPostClearRegion);
- mDevice->PrepareClearRegion(&mPostClear, Move(rects), Nothing());
+ mDevice->PrepareClearRegion(&mPostClear, std::move(rects), Nothing());
}
}
} // namespace layers
} // namespace mozilla
--- a/gfx/layers/mlgpu/StagingBuffer.h
+++ b/gfx/layers/mlgpu/StagingBuffer.h
@@ -257,17 +257,17 @@ protected:
} else {
size_t usedBytes = mPos - mBuffer.get();
MOZ_RELEASE_ASSERT(usedBytes <= newSize);
memcpy(newBuffer.get(), mBuffer.get(), usedBytes);
mPos = newBuffer.get() + usedBytes;
}
mEnd = newBuffer.get() + newSize;
- mBuffer = Move(newBuffer);
+ mBuffer = std::move(newBuffer);
MOZ_RELEASE_ASSERT(mPos >= mBuffer.get() && mPos <= mEnd);
return true;
}
protected:
UniquePtr<uint8_t[]> mBuffer;
uint8_t* mPos;
--- a/gfx/layers/mlgpu/TexturedLayerMLGPU.cpp
+++ b/gfx/layers/mlgpu/TexturedLayerMLGPU.cpp
@@ -115,17 +115,17 @@ TexturedLayerMLGPU::AssignToView(FrameBu
Maybe<Polygon>&& aGeometry)
{
if (mBigImageTexture) {
BigImageIterator* iter = mBigImageTexture->AsBigImageIterator();
iter->BeginBigImageIteration();
AssignBigImage(aBuilder, aView, iter, aGeometry);
iter->EndBigImageIteration();
} else {
- LayerMLGPU::AssignToView(aBuilder, aView, Move(aGeometry));
+ LayerMLGPU::AssignToView(aBuilder, aView, std::move(aGeometry));
}
}
void
TexturedLayerMLGPU::AssignBigImage(FrameBuilder* aBuilder,
RenderViewMLGPU* aView,
BigImageIterator* aIter,
const Maybe<Polygon>& aGeometry)
@@ -156,17 +156,17 @@ TexturedLayerMLGPU::AssignBigImage(Frame
continue;
}
// Create a temporary item.
RefPtr<TempImageLayerMLGPU> item = new TempImageLayerMLGPU(aBuilder->GetManager());
item->Init(this, tile, rect);
Maybe<Polygon> geometry = aGeometry;
- item->AddBoundsToView(aBuilder, aView, Move(geometry));
+ item->AddBoundsToView(aBuilder, aView, std::move(geometry));
// Since the layer tree is not holding this alive, we have to ask the
// FrameBuilder to do it for us.
aBuilder->RetainTemporaryLayer(item);
} while (aIter->NextTile());
}
TempImageLayerMLGPU::TempImageLayerMLGPU(LayerManagerMLGPU* aManager)
--- a/gfx/layers/wr/AsyncImagePipelineManager.h
+++ b/gfx/layers/wr/AsyncImagePipelineManager.h
@@ -92,17 +92,17 @@ public:
void AppendImageCompositeNotification(const ImageCompositeNotificationInfo& aNotification)
{
mImageCompositeNotifications.AppendElement(aNotification);
}
void FlushImageNotifications(nsTArray<ImageCompositeNotificationInfo>* aNotifications)
{
- aNotifications->AppendElements(Move(mImageCompositeNotifications));
+ aNotifications->AppendElements(std::move(mImageCompositeNotifications));
}
void SetWillGenerateFrame();
bool GetAndResetWillGenerateFrame();
private:
void ProcessPipelineRendered(const wr::PipelineId& aPipelineId, const wr::Epoch& aEpoch);
void ProcessPipelineRemoved(const wr::PipelineId& aPipelineId);
--- a/gfx/layers/wr/IpcResourceUpdateQueue.cpp
+++ b/gfx/layers/wr/IpcResourceUpdateQueue.cpp
@@ -240,17 +240,17 @@ ShmSegmentsReader::Read(const layers::Of
remainingBytesToCopy -= copyRange;
}
return aInto.Length() - initialLength == aRange.length();
}
IpcResourceUpdateQueue::IpcResourceUpdateQueue(layers::WebRenderBridgeChild* aAllocator,
size_t aChunkSize)
-: mWriter(Move(aAllocator), aChunkSize)
+: mWriter(std::move(aAllocator), aChunkSize)
{}
bool
IpcResourceUpdateQueue::AddImage(ImageKey key, const ImageDescriptor& aDescriptor,
Range<uint8_t> aBytes)
{
auto bytes = mWriter.Write(aBytes);
if (!bytes.length()) {
--- a/gfx/layers/wr/WebRenderBridgeChild.cpp
+++ b/gfx/layers/wr/WebRenderBridgeChild.cpp
@@ -107,17 +107,17 @@ WebRenderBridgeChild::UpdateResources(wr
return;
}
nsTArray<OpUpdateResource> resourceUpdates;
nsTArray<RefCountedShmem> smallShmems;
nsTArray<ipc::Shmem> largeShmems;
aResources.Flush(resourceUpdates, smallShmems, largeShmems);
- this->SendUpdateResources(resourceUpdates, Move(smallShmems), largeShmems);
+ this->SendUpdateResources(resourceUpdates, std::move(smallShmems), largeShmems);
}
void
WebRenderBridgeChild::EndTransaction(const wr::LayoutSize& aContentSize,
wr::BuiltDisplayList& aDL,
wr::IpcResourceUpdateQueue& aResources,
const gfx::IntSize& aSize,
TransactionId aTransactionId,
@@ -139,17 +139,17 @@ WebRenderBridgeChild::EndTransaction(con
nsTArray<OpUpdateResource> resourceUpdates;
nsTArray<RefCountedShmem> smallShmems;
nsTArray<ipc::Shmem> largeShmems;
aResources.Flush(resourceUpdates, smallShmems, largeShmems);
this->SendSetDisplayList(aSize, mParentCommands, mDestroyedActors,
GetFwdTransactionId(), aTransactionId,
aContentSize, dlData, aDL.dl_desc, aScrollData,
- Move(resourceUpdates), Move(smallShmems), largeShmems,
+ std::move(resourceUpdates), std::move(smallShmems), largeShmems,
mIdNamespace, aTxnStartTime, fwdTime);
mParentCommands.Clear();
mDestroyedActors.Clear();
mIsInTransaction = false;
}
void
--- a/gfx/layers/wr/WebRenderBridgeParent.cpp
+++ b/gfx/layers/wr/WebRenderBridgeParent.cpp
@@ -474,17 +474,17 @@ WebRenderBridgeParent::RecvUpdateResourc
mozilla::ipc::IPCResult
WebRenderBridgeParent::RecvDeleteCompositorAnimations(InfallibleTArray<uint64_t>&& aIds)
{
if (mDestroyed) {
return IPC_OK();
}
// Once mWrEpoch has been rendered, we can delete these compositor animations
- mCompositorAnimationsToDelete.push(CompositorAnimationIdsForEpoch(mWrEpoch, Move(aIds)));
+ mCompositorAnimationsToDelete.push(CompositorAnimationIdsForEpoch(mWrEpoch, std::move(aIds)));
return IPC_OK();
}
void
WebRenderBridgeParent::RemoveEpochDataPriorTo(const wr::Epoch& aRenderedEpoch)
{
while (!mCompositorAnimationsToDelete.empty()) {
if (mCompositorAnimationsToDelete.front().mEpoch.mHandle > aRenderedEpoch.mHandle) {
@@ -554,31 +554,31 @@ WebRenderBridgeParent::UpdateAPZScrollDa
WebRenderScrollData&& aData)
{
CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
if (!cbp) {
return;
}
LayersId rootLayersId = cbp->RootLayerTreeId();
if (RefPtr<APZUpdater> apz = cbp->GetAPZUpdater()) {
- apz->UpdateScrollDataAndTreeState(rootLayersId, GetLayersId(), aEpoch, Move(aData));
+ apz->UpdateScrollDataAndTreeState(rootLayersId, GetLayersId(), aEpoch, std::move(aData));
}
}
void
WebRenderBridgeParent::UpdateAPZScrollOffsets(ScrollUpdatesMap&& aUpdates,
uint32_t aPaintSequenceNumber)
{
CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
if (!cbp) {
return;
}
LayersId rootLayersId = cbp->RootLayerTreeId();
if (RefPtr<APZUpdater> apz = cbp->GetAPZUpdater()) {
- apz->UpdateScrollOffsets(rootLayersId, GetLayersId(), Move(aUpdates), aPaintSequenceNumber);
+ apz->UpdateScrollOffsets(rootLayersId, GetLayersId(), std::move(aUpdates), aPaintSequenceNumber);
}
}
void
WebRenderBridgeParent::SetAPZSampleTime()
{
CompositorBridgeParent* cbp = GetRootCompositorBridgeParent();
if (!cbp) {
@@ -645,19 +645,19 @@ WebRenderBridgeParent::RecvSetDisplayLis
// aScrollData is moved into this function but that is not reflected by the
// function signature due to the way the IPDL generator works. We remove the
// const so that we can move this structure all the way to the desired
// destination.
// Also note that this needs to happen before the display list transaction is
// sent to WebRender, so that the UpdateHitTestingTree call is guaranteed to
// be in the updater queue at the time that the scene swap completes.
- UpdateAPZScrollData(wrEpoch, Move(const_cast<WebRenderScrollData&>(aScrollData)));
+ UpdateAPZScrollData(wrEpoch, std::move(const_cast<WebRenderScrollData&>(aScrollData)));
- wr::Vec<uint8_t> dlData(Move(dl));
+ wr::Vec<uint8_t> dlData(std::move(dl));
// If id namespaces do not match, it means the command is obsolete, probably
// because the tab just moved to a new window.
// In that case do not send the commands to webrender.
if (mIdNamespace == aIdNamespace) {
if (mWidget) {
LayoutDeviceIntSize widgetSize = mWidget->GetClientSize();
LayoutDeviceIntRect docRect(LayoutDeviceIntPoint(), widgetSize);
@@ -727,17 +727,17 @@ WebRenderBridgeParent::RecvEmptyTransact
bool scheduleComposite = false;
UpdateAPZFocusState(aFocusTarget);
if (!aUpdates.empty()) {
// aUpdates is moved into this function but that is not reflected by the
// function signature due to the way the IPDL generator works. We remove the
// const so that we can move this structure all the way to the desired
// destination.
- UpdateAPZScrollOffsets(Move(const_cast<ScrollUpdatesMap&>(aUpdates)), aPaintSequenceNumber);
+ UpdateAPZScrollOffsets(std::move(const_cast<ScrollUpdatesMap&>(aUpdates)), aPaintSequenceNumber);
scheduleComposite = true;
}
if (!aCommands.IsEmpty()) {
mAsyncImageManager->SetCompositionTime(TimeStamp::Now());
wr::TransactionBuilder txn;
wr::Epoch wrEpoch = GetNextWrEpoch();
txn.UpdateEpoch(mPipelineId, wrEpoch);
@@ -832,17 +832,17 @@ WebRenderBridgeParent::ProcessWebRenderP
case WebRenderParentCommand::TCompositableOperation: {
if (!ReceiveCompositableUpdate(cmd.get_CompositableOperation())) {
NS_ERROR("ReceiveCompositableUpdate failed");
}
break;
}
case WebRenderParentCommand::TOpAddCompositorAnimations: {
const OpAddCompositorAnimations& op = cmd.get_OpAddCompositorAnimations();
- CompositorAnimations data(Move(op.data()));
+ CompositorAnimations data(std::move(op.data()));
if (data.animations().Length()) {
mAnimStorage->SetAnimations(data.id(), data.animations());
mActiveAnimations.insert(data.id());
}
break;
}
default: {
// other commands are handle on the child
--- a/gfx/layers/wr/WebRenderBridgeParent.h
+++ b/gfx/layers/wr/WebRenderBridgeParent.h
@@ -254,17 +254,17 @@ private:
TransactionId mId;
TimeStamp mTxnStartTime;
TimeStamp mFwdTime;
};
struct CompositorAnimationIdsForEpoch {
CompositorAnimationIdsForEpoch(const wr::Epoch& aEpoch, InfallibleTArray<uint64_t>&& aIds)
: mEpoch(aEpoch)
- , mIds(Move(aIds))
+ , mIds(std::move(aIds))
{
}
wr::Epoch mEpoch;
InfallibleTArray<uint64_t> mIds;
};
CompositorBridgeParentBase* MOZ_NON_OWNING_REF mCompositorBridge;
--- a/gfx/layers/wr/WebRenderCommandBuilder.cpp
+++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ -382,17 +382,17 @@ struct DIGroup
}*/
GP("pre mInvalidRect: %s %p-%d - inv: %d %d %d %d\n", aItem->Name(), aItem->Frame(), aItem->GetPerFrameKey(),
mInvalidRect.x, mInvalidRect.y, mInvalidRect.width, mInvalidRect.height);
if (!aData->mGeometry) {
// This item is being added for the first time, invalidate its entire area.
UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));
combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());
- aData->mGeometry = Move(geometry);
+ aData->mGeometry = std::move(geometry);
nsRect bounds = combined.GetBounds();
IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
aData->mRect = transformedRect.Intersect(imageRect);
GP("CGC %s %d %d %d %d\n", aItem->Name(), bounds.x, bounds.y, bounds.width, bounds.height);
GP("%d %d, %f %f\n", mLayerBounds.TopLeft().x, mLayerBounds.TopLeft().y, aMatrix._11, aMatrix._22);
GP("mRect %d %d %d %d\n", aData->mRect.x, aData->mRect.y, aData->mRect.width, aData->mRect.height);
InvalidateRect(aData->mRect);
@@ -401,20 +401,20 @@ struct DIGroup
MOZ_RELEASE_ASSERT(imageRect.IsEqualEdges(aData->mImageRect));
MOZ_RELEASE_ASSERT(mLayerBounds.TopLeft() == aData->mGroupOffset);
UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));
/* Instead of doing this dance, let's just invalidate the old rect and the
* new rect.
combined = aData->mClip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion());
combined.MoveBy(shift);
combined.Or(combined, clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion()));
- aData->mGeometry = Move(geometry);
+ aData->mGeometry = std::move(geometry);
*/
combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());
- aData->mGeometry = Move(geometry);
+ aData->mGeometry = std::move(geometry);
GP("matrix: %f %f\n", aMatrix._31, aMatrix._32);
GP("frame invalid invalidate: %s\n", aItem->Name());
GP("old rect: %d %d %d %d\n",
aData->mRect.x,
aData->mRect.y,
aData->mRect.width,
aData->mRect.height);
@@ -447,33 +447,33 @@ struct DIGroup
aData->mGeometry->ComputeInvalidationRegion(),
&combined);
IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
IntRect invalidRect = transformedRect.Intersect(imageRect);
GP("combined not empty: mRect %d %d %d %d\n", invalidRect.x, invalidRect.y, invalidRect.width, invalidRect.height);
// invalidate the invalidated area.
InvalidateRect(invalidRect);
- aData->mGeometry = Move(geometry);
+ aData->mGeometry = std::move(geometry);
combined = clip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion());
transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
aData->mRect = transformedRect.Intersect(imageRect);
aData->mInvalid = true;
} else {
if (aData->mClip != clip) {
UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));
if (!IsContainerLayerItem(aItem)) {
// the bounds of layer items can change on us without ComputeInvalidationRegion
// returning any change. Other items shouldn't have any hidden
// geometry change.
MOZ_RELEASE_ASSERT(geometry->mBounds.IsEqualEdges(aData->mGeometry->mBounds));
} else {
- aData->mGeometry = Move(geometry);
+ aData->mGeometry = std::move(geometry);
}
combined = clip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion());
IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
InvalidateRect(aData->mRect.Intersect(imageRect));
aData->mRect = transformedRect.Intersect(imageRect);
InvalidateRect(aData->mRect);
GP("ClipChange: %s %d %d %d %d\n", aItem->Name(),
@@ -487,33 +487,33 @@ struct DIGroup
// using the style sytem UpdateTransformLayer hint and check for that.
UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));
if (!IsContainerLayerItem(aItem)) {
// the bounds of layer items can change on us
// other items shouldn't
MOZ_RELEASE_ASSERT(geometry->mBounds.IsEqualEdges(aData->mGeometry->mBounds));
} else {
- aData->mGeometry = Move(geometry);
+ aData->mGeometry = std::move(geometry);
}
combined = clip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion());
IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
InvalidateRect(aData->mRect.Intersect(imageRect));
aData->mRect = transformedRect.Intersect(imageRect);
InvalidateRect(aData->mRect);
GP("TransformChange: %s %d %d %d %d\n", aItem->Name(),
aData->mRect.x, aData->mRect.y, aData->mRect.XMost(), aData->mRect.YMost());
} else if (IsContainerLayerItem(aItem)) {
UniquePtr<nsDisplayItemGeometry> geometry(aItem->AllocateGeometry(aBuilder));
// we need to catch bounds changes of containers so that we continue to have the correct bounds rects in the recording
if (!geometry->mBounds.IsEqualEdges(aData->mGeometry->mBounds) ||
UpdateContainerLayerPropertiesAndDetectChange(aItem, aData)) {
combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());
- aData->mGeometry = Move(geometry);
+ aData->mGeometry = std::move(geometry);
IntRect transformedRect = ToDeviceSpace(combined.GetBounds(), aMatrix, appUnitsPerDevPixel, mLayerBounds.TopLeft());
InvalidateRect(aData->mRect.Intersect(imageRect));
aData->mRect = transformedRect.Intersect(imageRect);
InvalidateRect(aData->mRect);
GP("UpdateContainerLayerPropertiesAndDetectChange change\n");
} else {
// XXX: this code can eventually be deleted/made debug only
combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion());
@@ -1538,17 +1538,17 @@ PaintByLayer(nsDisplayItem* aItem,
nsDisplayListBuilder* aDisplayListBuilder,
const RefPtr<BasicLayerManager>& aManager,
gfxContext* aContext,
const gfx::Size& aScale,
const std::function<void()>& aPaintFunc)
{
UniquePtr<LayerProperties> props;
if (aManager->GetRoot()) {
- props = Move(LayerProperties::CloneFrom(aManager->GetRoot()));
+ props = std::move(LayerProperties::CloneFrom(aManager->GetRoot()));
}
FrameLayerBuilder* layerBuilder = new FrameLayerBuilder();
layerBuilder->Init(aDisplayListBuilder, aManager, nullptr, true);
layerBuilder->DidBeginRetainedLayerTransaction(aManager);
aManager->SetDefaultTarget(aContext);
aManager->BeginTransactionWithTarget(aContext);
bool isInvalidated = false;
@@ -1765,17 +1765,17 @@ WebRenderCommandBuilder::GenerateFallbac
}
}
needPaint = !invalidRegion.IsEmpty();
}
if (needPaint || !fallbackData->GetKey()) {
nsAutoPtr<nsDisplayItemGeometry> newGeometry;
newGeometry = aItem->AllocateGeometry(aDisplayListBuilder);
- fallbackData->SetGeometry(Move(newGeometry));
+ fallbackData->SetGeometry(std::move(newGeometry));
gfx::SurfaceFormat format = aItem->GetType() == DisplayItemType::TYPE_MASK ?
gfx::SurfaceFormat::A8 : gfx::SurfaceFormat::B8G8R8A8;
if (useBlobImage) {
bool snapped;
bool isOpaque = aItem->GetOpaqueRegion(aDisplayListBuilder, &snapped).Contains(paintBounds);
RefPtr<WebRenderDrawEventRecorder> recorder =
--- a/gfx/skia/skia/src/core/SkPath.cpp
+++ b/gfx/skia/skia/src/core/SkPath.cpp
@@ -117,17 +117,17 @@ private:
};
#define SkAutoPathBoundsUpdate(...) SK_REQUIRE_LOCAL_VAR(SkAutoPathBoundsUpdate)
////////////////////////////////////////////////////////////////////////////
/*
Stores the verbs and points as they are given to us, with exceptions:
- we only record "Close" if it was immediately preceeded by Move | Line | Quad | Cubic
- - we insert a Move(0,0) if Line | Quad | Cubic is our first command
+ - we insert a std::move(0,0) if Line | Quad | Cubic is our first command
The iterator does more cleanup, especially if forceClose == true
1. If we encounter degenerate segments, remove them
2. if we encounter Close, return a cons'd up Line() first (if the curr-pt != start-pt)
3. if we encounter Move without a preceeding Close, and forceClose is true, goto #2
4. if we encounter Line | Quad | Cubic after Close, cons up a Move
*/
--- a/gfx/src/TiledRegion.h
+++ b/gfx/src/TiledRegion.h
@@ -52,17 +52,17 @@ public:
TiledRegion(const TiledRegion& aOther)
: mBounds(aOther.mBounds)
, mImpl(aOther.mImpl)
, mCoversBounds(false)
{}
TiledRegion(TiledRegion&& aOther)
: mBounds(aOther.mBounds)
- , mImpl(Move(aOther.mImpl))
+ , mImpl(std::move(aOther.mImpl))
, mCoversBounds(false)
{}
RegionT GetRegion() const
{
if (mBounds.IsEmpty()) {
return RegionT();
}
--- a/gfx/src/nsDeviceContext.cpp
+++ b/gfx/src/nsDeviceContext.cpp
@@ -741,17 +741,17 @@ nsDeviceContext::IsSyncPagePrinting() co
MOZ_ASSERT(mPrintTarget);
return mPrintTarget->IsSyncPagePrinting();
}
void
nsDeviceContext::RegisterPageDoneCallback(PrintTarget::PageDoneCallback&& aCallback)
{
MOZ_ASSERT(mPrintTarget && aCallback && !IsSyncPagePrinting());
- mPrintTarget->RegisterPageDoneCallback(Move(aCallback));
+ mPrintTarget->RegisterPageDoneCallback(std::move(aCallback));
}
void
nsDeviceContext::UnregisterPageDoneCallback()
{
if (mPrintTarget) {
mPrintTarget->UnregisterPageDoneCallback();
}
}
--- a/gfx/src/nsRegion.h
+++ b/gfx/src/nsRegion.h
@@ -2244,20 +2244,20 @@ public:
typedef Rect RectType;
typedef Point PointType;
typedef Margin MarginType;
BaseIntRegion () {}
MOZ_IMPLICIT BaseIntRegion (const Rect& aRect) : mImpl (ToRect(aRect)) {}
explicit BaseIntRegion (mozilla::gfx::ArrayView<pixman_box32_t> aRects) : mImpl (aRects) {}
BaseIntRegion (const BaseIntRegion& aRegion) : mImpl (aRegion.mImpl) {}
- BaseIntRegion (BaseIntRegion&& aRegion) : mImpl (mozilla::Move(aRegion.mImpl)) {}
+ BaseIntRegion (BaseIntRegion&& aRegion) : mImpl (std::move(aRegion.mImpl)) {}
Derived& operator = (const Rect& aRect) { mImpl = ToRect (aRect); return This(); }
Derived& operator = (const Derived& aRegion) { mImpl = aRegion.mImpl; return This(); }
- Derived& operator = (Derived&& aRegion) { mImpl = mozilla::Move(aRegion.mImpl); return This(); }
+ Derived& operator = (Derived&& aRegion) { mImpl = std::move(aRegion.mImpl); return This(); }
bool operator==(const Derived& aRgn) const
{
return IsEqual(aRgn);
}
bool operator!=(const Derived& aRgn) const
{
return !(*this == aRgn);
@@ -2590,27 +2590,27 @@ public:
typedef IntPointTyped<units> PointType;
typedef IntMarginTyped<units> MarginType;
// Forward constructors.
IntRegionTyped() {}
MOZ_IMPLICIT IntRegionTyped(const IntRectTyped<units>& aRect) : Super(aRect) {}
IntRegionTyped(const IntRegionTyped& aRegion) : Super(aRegion) {}
explicit IntRegionTyped(mozilla::gfx::ArrayView<pixman_box32_t> aRects) : Super(aRects) {}
- IntRegionTyped(IntRegionTyped&& aRegion) : Super(mozilla::Move(aRegion)) {}
+ IntRegionTyped(IntRegionTyped&& aRegion) : Super(std::move(aRegion)) {}
// Assignment operators need to be forwarded as well, otherwise the compiler
// will declare deleted ones.
IntRegionTyped& operator=(const IntRegionTyped& aRegion)
{
return Super::operator=(aRegion);
}
IntRegionTyped& operator=(IntRegionTyped&& aRegion)
{
- return Super::operator=(mozilla::Move(aRegion));
+ return Super::operator=(std::move(aRegion));
}
static IntRegionTyped FromUnknownRegion(const IntRegion& aRegion)
{
return IntRegionTyped(aRegion.Impl());
}
IntRegion ToUnknownRegion() const
{
--- a/gfx/src/nsThebesFontEnumerator.cpp
+++ b/gfx/src/nsThebesFontEnumerator.cpp
@@ -92,17 +92,17 @@ struct EnumerateFontsPromise final
class EnumerateFontsResult final : public Runnable
{
public:
EnumerateFontsResult(nsresult aRv,
UniquePtr<EnumerateFontsPromise> aEnumerateFontsPromise,
nsTArray<nsString> aFontList)
: Runnable("EnumerateFontsResult")
, mRv(aRv)
- , mEnumerateFontsPromise(Move(aEnumerateFontsPromise))
+ , mEnumerateFontsPromise(std::move(aEnumerateFontsPromise))
, mFontList(aFontList)
, mWorkerThread(do_GetCurrentThread())
{
MOZ_ASSERT(!NS_IsMainThread());
}
NS_IMETHOD Run() override
{
@@ -131,32 +131,32 @@ class EnumerateFontsTask final : public
public:
EnumerateFontsTask(nsAtom* aLangGroupAtom,
const nsAutoCString& aGeneric,
UniquePtr<EnumerateFontsPromise> aEnumerateFontsPromise,
nsIEventTarget* aMainThreadTarget)
: Runnable("EnumerateFontsTask")
, mLangGroupAtom(aLangGroupAtom)
, mGeneric(aGeneric)
- , mEnumerateFontsPromise(Move(aEnumerateFontsPromise))
+ , mEnumerateFontsPromise(std::move(aEnumerateFontsPromise))
, mMainThreadTarget(aMainThreadTarget)
{
MOZ_ASSERT(NS_IsMainThread());
}
NS_IMETHOD Run() override
{
MOZ_ASSERT(!NS_IsMainThread());
nsTArray<nsString> fontList;
nsresult rv = gfxPlatform::GetPlatform()->
GetFontList(mLangGroupAtom, mGeneric, fontList);
nsCOMPtr<nsIRunnable> runnable = new EnumerateFontsResult(
- rv, Move(mEnumerateFontsPromise), Move(fontList));
+ rv, std::move(mEnumerateFontsPromise), std::move(fontList));
mMainThreadTarget->Dispatch(runnable.forget());
return NS_OK;
}
private:
RefPtr<nsAtom> mLangGroupAtom;
nsAutoCStringN<16> mGeneric;
@@ -207,17 +207,17 @@ nsThebesFontEnumerator::EnumerateFontsAs
if (aGeneric) {
generic.Assign(aGeneric);
} else {
generic.SetIsVoid(true);
}
nsCOMPtr<nsIEventTarget> target = global->EventTargetFor(mozilla::TaskCategory::Other);
nsCOMPtr<nsIRunnable> runnable = new EnumerateFontsTask(
- langGroupAtom, generic, Move(enumerateFontsPromise), target);
+ langGroupAtom, generic, std::move(enumerateFontsPromise), target);
thread->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
if (!ToJSValue(aCx, promise, aRval)) {
return NS_ERROR_FAILURE;
}
return NS_OK;
}
--- a/gfx/tests/gtest/MockWidget.h
+++ b/gfx/tests/gtest/MockWidget.h
@@ -53,17 +53,17 @@ public:
const LayoutDeviceIntRect& aRect,
nsWidgetInitData* aInitData = nullptr) override { return NS_OK; }
virtual nsresult Create(nsIWidget* aParent,
nsNativeWidget aNativeParent,
const DesktopIntRect& aRect,
nsWidgetInitData* aInitData = nullptr) override { return NS_OK; }
virtual void Show(bool aState) override {}
virtual bool IsVisible() const override { return true; }
- virtual void Move(double aX, double aY) override {}
+ virtual void std::move(double aX, double aY) override {}
virtual void Resize(double aWidth, double aHeight, bool aRepaint) override {}
virtual void Resize(double aX, double aY,
double aWidth, double aHeight, bool aRepaint) override {}
virtual void Enable(bool aState) override {}
virtual bool IsEnabled() const override { return true; }
virtual nsresult SetFocus(bool aRaise) override { return NS_OK; }
virtual nsresult ConfigureChildren(const nsTArray<Configuration>& aConfigurations) override { return NS_OK; }
--- a/gfx/tests/gtest/TestBSPTree.cpp
+++ b/gfx/tests/gtest/TestBSPTree.cpp
@@ -19,17 +19,17 @@ typedef mozilla::gfx::Polygon MozPolygon
namespace {
static void RunTest(std::deque<MozPolygon> aPolygons,
std::deque<MozPolygon> aExpected)
{
std::list<LayerPolygon> layers;
for (MozPolygon& polygon : aPolygons) {
- layers.push_back(LayerPolygon(nullptr, Move(polygon)));
+ layers.push_back(LayerPolygon(nullptr, std::move(polygon)));
}
const BSPTree tree(layers);
const nsTArray<LayerPolygon> order = tree.GetDrawOrder();
EXPECT_EQ(aExpected.size(), order.Length());
for (size_t i = 0; i < order.Length(); ++i) {
--- a/gfx/thebes/PrintTarget.cpp
+++ b/gfx/thebes/PrintTarget.cpp
@@ -206,17 +206,17 @@ PrintTarget::Finish()
// null surfaces are allowed here
cairo_surface_finish(mCairoSurface);
}
void
PrintTarget::RegisterPageDoneCallback(PageDoneCallback&& aCallback)
{
MOZ_ASSERT(aCallback && !IsSyncPagePrinting());
- mPageDoneCallback = Move(aCallback);
+ mPageDoneCallback = std::move(aCallback);
}
void
PrintTarget::UnregisterPageDoneCallback()
{
mPageDoneCallback = nullptr;
}
--- a/gfx/thebes/PrintTargetEMF.cpp
+++ b/gfx/thebes/PrintTargetEMF.cpp
@@ -110,17 +110,17 @@ PrintTargetEMF::BeginPage()
NS_CopyUnicodeToNative(filePathU, filePath);
#else
mPDFFileForOnePage->GetNativePath(filePath);
#endif
auto stream = MakeUnique<SkFILEWStream>(filePath.get());
// Creating a new PrintTargetSkPDF for each page so that we can convert each
// of them into EMF contents individually by the PDFium processes.
- mTargetForCurrentPage = PrintTargetSkPDF::CreateOrNull(Move(stream), mSize);
+ mTargetForCurrentPage = PrintTargetSkPDF::CreateOrNull(std::move(stream), mSize);
mTargetForCurrentPage->BeginPrinting(mTitle, NS_LITERAL_STRING(""), 0, 0);
mTargetForCurrentPage->BeginPage();
return NS_OK;
}
nsresult
PrintTargetEMF::EndPage()
@@ -157,17 +157,17 @@ PrintTargetEMF::MakeDrawTarget(const Int
return mTargetForCurrentPage->MakeDrawTarget(aSize, aRecorder);
}
already_AddRefed<DrawTarget>
PrintTargetEMF::GetReferenceDrawTarget()
{
if (!mRefTarget) {
auto dummy = MakeUnique<SkNullWStream>();
- mRefTarget = PrintTargetSkPDF::CreateOrNull(Move(dummy), mSize);
+ mRefTarget = PrintTargetSkPDF::CreateOrNull(std::move(dummy), mSize);
}
if (!mRefDT) {
mRefDT = mRefTarget->GetReferenceDrawTarget();
}
return mRefDT.forget();
}
--- a/gfx/thebes/PrintTargetSkPDF.cpp
+++ b/gfx/thebes/PrintTargetSkPDF.cpp
@@ -10,17 +10,17 @@
#include <vector>
namespace mozilla {
namespace gfx {
PrintTargetSkPDF::PrintTargetSkPDF(const IntSize& aSize,
UniquePtr<SkWStream> aStream)
: PrintTarget(/* not using cairo_surface_t */ nullptr, aSize)
- , mOStream(Move(aStream))
+ , mOStream(std::move(aStream))
, mPageCanvas(nullptr)
{
}
PrintTargetSkPDF::~PrintTargetSkPDF()
{
Finish(); // ensure stream is flushed
@@ -29,17 +29,17 @@ PrintTargetSkPDF::~PrintTargetSkPDF()
mPDFDoc = nullptr;
mRefPDFDoc = nullptr;
}
/* static */ already_AddRefed<PrintTargetSkPDF>
PrintTargetSkPDF::CreateOrNull(UniquePtr<SkWStream> aStream,
const IntSize& aSizeInPoints)
{
- return do_AddRef(new PrintTargetSkPDF(aSizeInPoints, Move(aStream)));
+ return do_AddRef(new PrintTargetSkPDF(aSizeInPoints, std::move(aStream)));
}
nsresult
PrintTargetSkPDF::BeginPrinting(const nsAString& aTitle,
const nsAString& aPrintToFileName,
int32_t aStartPage,
int32_t aEndPage)
{
--- a/gfx/thebes/gfxBlur.cpp
+++ b/gfx/thebes/gfxBlur.cpp
@@ -344,17 +344,17 @@ struct BlurCacheKey : public PLDHashEntr
/**
* This class is what is cached. It need to be allocated in an object separated
* to the cache entry to be able to be tracked by the nsExpirationTracker.
* */
struct BlurCacheData {
BlurCacheData(SourceSurface* aBlur, const IntMargin& aBlurMargin, BlurCacheKey&& aKey)
: mBlur(aBlur)
, mBlurMargin(aBlurMargin)
- , mKey(Move(aKey))
+ , mKey(std::move(aKey))
{}
BlurCacheData(BlurCacheData&& aOther) = default;
nsExpirationState *GetExpirationState() {
return &mExpirationState;
}
@@ -499,17 +499,17 @@ CacheBlur(DrawTarget* aDT,
const IntSize& aMinSize,
const IntSize& aBlurRadius,
const RectCornerRadii* aCornerRadii,
const Color& aShadowColor,
const IntMargin& aBlurMargin,
SourceSurface* aBoxShadow)
{
BlurCacheKey key(aMinSize, aBlurRadius, aCornerRadii, aShadowColor, aDT->GetBackendType());
- BlurCacheData* data = new BlurCacheData(aBoxShadow, aBlurMargin, Move(key));
+ BlurCacheData* data = new BlurCacheData(aBoxShadow, aBlurMargin, std::move(key));
if (!gBlurCache->RegisterEntry(data)) {
delete data;
}
}
// Blurs a small surface and creates the colored box shadow.
static already_AddRefed<SourceSurface>
CreateBoxShadow(DrawTarget* aDestDrawTarget,
@@ -1081,17 +1081,17 @@ CacheInsetBlur(const IntSize& aMinOuterS
SourceSurface* aBoxShadow)
{
bool isInsetBlur = true;
BlurCacheKey key(aMinOuterSize, aMinInnerSize,
aBlurRadius, aCornerRadii,
aShadowColor, isInsetBlur,
aBackendType);
IntMargin blurMargin(0, 0, 0, 0);
- BlurCacheData* data = new BlurCacheData(aBoxShadow, blurMargin, Move(key));
+ BlurCacheData* data = new BlurCacheData(aBoxShadow, blurMargin, std::move(key));
if (!gBlurCache->RegisterEntry(data)) {
delete data;
}
}
already_AddRefed<SourceSurface>
gfxAlphaBoxBlur::GetInsetBlur(const Rect& aOuterRect,
const Rect& aWhitespaceRect,
--- a/gfx/thebes/gfxFT2FontList.cpp
+++ b/gfx/thebes/gfxFT2FontList.cpp
@@ -1667,12 +1667,12 @@ gfxFT2FontList::WillShutdown()
mozilla::scache::StartupCache* cache =
mozilla::scache::StartupCache::GetSingleton();
if (cache && mJarModifiedTime > 0) {
const size_t bufSize = sizeof(mJarModifiedTime);
auto buf = MakeUnique<char[]>(bufSize);
memcpy(buf.get(), &mJarModifiedTime, bufSize);
cache->PutBuffer(JAR_LAST_MODIFED_TIME,
- Move(buf), bufSize);
+ std::move(buf), bufSize);
}
mFontNameCache = nullptr;
}
--- a/gfx/thebes/gfxFcPlatformFontList.cpp
+++ b/gfx/thebes/gfxFcPlatformFontList.cpp
@@ -896,21 +896,21 @@ PreparePattern(FcPattern* aPattern, bool
FcDefaultSubstitute(aPattern);
}
void
gfxFontconfigFontEntry::UnscaledFontCache::MoveToFront(size_t aIndex) {
if (aIndex > 0) {
ThreadSafeWeakPtr<UnscaledFontFontconfig> front =
- Move(mUnscaledFonts[aIndex]);
+ std::move(mUnscaledFonts[aIndex]);
for (size_t i = aIndex; i > 0; i--) {
- mUnscaledFonts[i] = Move(mUnscaledFonts[i-1]);
+ mUnscaledFonts[i] = std::move(mUnscaledFonts[i-1]);
}
- mUnscaledFonts[0] = Move(front);
+ mUnscaledFonts[0] = std::move(front);
}
}
already_AddRefed<UnscaledFontFontconfig>
gfxFontconfigFontEntry::UnscaledFontCache::Lookup(const char* aFile, uint32_t aIndex) {
for (size_t i = 0; i < kNumEntries; i++) {
RefPtr<UnscaledFontFontconfig> entry(mUnscaledFonts[i]);
if (entry &&
--- a/gfx/thebes/gfxFont.cpp
+++ b/gfx/thebes/gfxFont.cpp
@@ -2549,17 +2549,17 @@ gfxFont::Measure(const gfxTextRun *aText
{
// If aBoundingBoxType is TIGHT_HINTED_OUTLINE_EXTENTS
// and the underlying cairo font may be antialiased,
// we need to create a copy in order to avoid getting cached extents.
// This is only used by MathML layout at present.
if (aBoundingBoxType == TIGHT_HINTED_OUTLINE_EXTENTS &&
mAntialiasOption != kAntialiasNone) {
if (!mNonAAFont) {
- mNonAAFont = Move(CopyWithAntialiasOption(kAntialiasNone));
+ mNonAAFont = std::move(CopyWithAntialiasOption(kAntialiasNone));
}
// if font subclass doesn't implement CopyWithAntialiasOption(),
// it will return null and we'll proceed to use the existing font
if (mNonAAFont) {
return mNonAAFont->Measure(aTextRun, aStart, aEnd,
TIGHT_HINTED_OUTLINE_EXTENTS,
aRefDrawTarget, aSpacing, aOrientation);
}
@@ -4070,17 +4070,17 @@ gfxFont::CreateVerticalMetrics()
// Somewhat arbitrary values for now, subject to future refinement...
metrics->spaceWidth = metrics->aveCharWidth;
metrics->zeroOrAveCharWidth = metrics->aveCharWidth;
metrics->maxHeight = metrics->maxAscent + metrics->maxDescent;
metrics->xHeight = metrics->emHeight / 2;
metrics->capHeight = metrics->maxAscent;
- return Move(metrics);
+ return std::move(metrics);
}
gfxFloat
gfxFont::SynthesizeSpaceWidth(uint32_t aCh)
{
// return an appropriate width for various Unicode space characters
// that we "fake" if they're not actually present in the font;
// returns negative value if the char is not a known space.
--- a/gfx/thebes/gfxFontEntry.cpp
+++ b/gfx/thebes/gfxFontEntry.cpp
@@ -186,17 +186,17 @@ nsresult gfxFontEntry::InitializeUVSMap(
(const uint8_t*)cmapData + mUVSOffset,
cmapLen - mUVSOffset, uvsData);
if (NS_FAILED(rv)) {
mUVSOffset = 0; // don't bother to read the table again
return rv;
}
- mUVSData = Move(uvsData);
+ mUVSData = std::move(uvsData);
}
return NS_OK;
}
uint16_t gfxFontEntry::GetUVSGlyph(uint32_t aCh, uint32_t aVS)
{
InitializeUVSMap();
@@ -408,17 +408,17 @@ gfxFontEntry::TryGetColorGlyphs()
* FontTableBlobData
*
* See FontTableHashEntry for the general strategy.
*/
class gfxFontEntry::FontTableBlobData {
public:
explicit FontTableBlobData(nsTArray<uint8_t>&& aBuffer)
- : mTableData(Move(aBuffer))
+ : mTableData(std::move(aBuffer))
, mHashtable(nullptr)
, mHashKey(0)
{
MOZ_COUNT_CTOR(FontTableBlobData);
}
~FontTableBlobData() {
MOZ_COUNT_DTOR(FontTableBlobData);
@@ -473,17 +473,17 @@ private:
hb_blob_t *
gfxFontEntry::FontTableHashEntry::
ShareTableAndGetBlob(nsTArray<uint8_t>&& aTable,
nsTHashtable<FontTableHashEntry> *aHashtable)
{
Clear();
// adopts elements of aTable
- mSharedBlobData = new FontTableBlobData(Move(aTable));
+ mSharedBlobData = new FontTableBlobData(std::move(aTable));
mBlob = hb_blob_create(mSharedBlobData->GetTable(),
mSharedBlobData->GetTableLength(),
HB_MEMORY_MODE_READONLY,
mSharedBlobData, DeleteFontTableBlobData);
if (mBlob == hb_blob_get_empty() ) {
// The FontTableBlobData was destroyed during hb_blob_create().
// The (empty) blob is still be held in the hashtable with a strong
@@ -560,17 +560,17 @@ gfxFontEntry::ShareFontTableAndGetBlob(u
}
if (!aBuffer) {
// ensure the entry is null
entry->Clear();
return nullptr;
}
- return entry->ShareTableAndGetBlob(Move(*aBuffer), mFontTableCache.get());
+ return entry->ShareTableAndGetBlob(std::move(*aBuffer), mFontTableCache.get());
}
already_AddRefed<gfxCharacterMap>
gfxFontEntry::GetCMAPFromFontInfo(FontInfoData *aFontInfoData,
uint32_t& aUVSOffset)
{
if (!aFontInfoData || !aFontInfoData->mLoadCmaps) {
return nullptr;
--- a/gfx/thebes/gfxFontEntry.h
+++ b/gfx/thebes/gfxFontEntry.h
@@ -616,19 +616,19 @@ private:
, mSharedBlobData(nullptr)
, mBlob(nullptr)
{ }
// NOTE: This assumes the new entry belongs to the same hashtable as
// the old, because the mHashtable pointer in mSharedBlobData (if
// present) will not be updated.
FontTableHashEntry(FontTableHashEntry&& toMove)
- : KeyClass(mozilla::Move(toMove))
- , mSharedBlobData(mozilla::Move(toMove.mSharedBlobData))
- , mBlob(mozilla::Move(toMove.mBlob))
+ : KeyClass(std::move(toMove))
+ , mSharedBlobData(std::move(toMove.mSharedBlobData))
+ , mBlob(std::move(toMove.mBlob))
{
toMove.mSharedBlobData = nullptr;
toMove.mBlob = nullptr;
}
~FontTableHashEntry() { Clear(); }
// FontTable/Blob API
--- a/gfx/thebes/gfxFontFamilyList.h
+++ b/gfx/thebes/gfxFontFamilyList.h
@@ -194,17 +194,17 @@ public:
}
explicit SharedFontList(const FontFamilyName& aName)
: mNames { aName }
{
}
explicit SharedFontList(nsTArray<FontFamilyName>&& aNames)
- : mNames(Move(aNames))
+ : mNames(std::move(aNames))
{
}
FontFamilyType FirstGeneric() const
{
for (const FontFamilyName& name : mNames) {
if (name.IsGeneric()) {
return name.mType;
@@ -276,17 +276,17 @@ public:
explicit FontFamilyList(const FontFamilyName& aName)
: mFontlist(MakeNotNull<SharedFontList*>(aName))
, mDefaultFontType(eFamily_none)
{
}
explicit FontFamilyList(nsTArray<FontFamilyName>&& aNames)
- : mFontlist(MakeNotNull<SharedFontList*>(Move(aNames)))
+ : mFontlist(MakeNotNull<SharedFontList*>(std::move(aNames)))
{
}
FontFamilyList(const FontFamilyList& aOther)
: mFontlist(aOther.mFontlist)
, mDefaultFontType(aOther.mDefaultFontType)
{
}
@@ -294,17 +294,17 @@ public:
explicit FontFamilyList(NotNull<SharedFontList*> aFontList)
: mFontlist(aFontList)
, mDefaultFontType(eFamily_none)
{
}
void SetFontlist(nsTArray<FontFamilyName>&& aNames)
{
- mFontlist = MakeNotNull<SharedFontList*>(Move(aNames));
+ mFontlist = MakeNotNull<SharedFontList*>(std::move(aNames));
}
void SetFontlist(NotNull<SharedFontList*> aFontlist)
{
mFontlist = aFontlist;
}
uint32_t Length() const {
@@ -355,29 +355,29 @@ public:
name.mType == eFamily_fantasy) {
continue;
}
if (i > 0) {
nsTArray<FontFamilyName> names;
names.AppendElements(mFontlist->mNames);
names.RemoveElementAt(i);
names.InsertElementAt(0, name);
- SetFontlist(Move(names));
+ SetFontlist(std::move(names));
}
return true;
}
}
return false;
}
void PrependGeneric(FontFamilyType aType) {
nsTArray<FontFamilyName> names;
names.AppendElements(mFontlist->mNames);
names.InsertElementAt(0, FontFamilyName(aType));
- SetFontlist(Move(names));
+ SetFontlist(std::move(names));
}
void ToString(nsAString& aFamilyList,
bool aQuotes = true,
bool aIncludeDefault = false) const {
const nsTArray<FontFamilyName>& names = mFontlist->mNames;
aFamilyList.Truncate();
uint32_t len = names.Length();
--- a/gfx/thebes/gfxGradientCache.cpp
+++ b/gfx/thebes/gfxGradientCache.cpp
@@ -84,17 +84,17 @@ struct GradientCacheKey : public PLDHash
/**
* This class is what is cached. It need to be allocated in an object separated
* to the cache entry to be able to be tracked by the nsExpirationTracker.
* */
struct GradientCacheData {
GradientCacheData(GradientStops* aStops, GradientCacheKey&& aKey)
: mStops(aStops),
- mKey(Move(aKey))
+ mKey(std::move(aKey))
{}
GradientCacheData(GradientCacheData&& aOther) = default;
nsExpirationState *GetExpirationState() {
return &mExpirationState;
}
--- a/gfx/thebes/gfxPlatform.cpp
+++ b/gfx/thebes/gfxPlatform.cpp
@@ -1816,17 +1816,17 @@ gfxPlatform::GetBackendPrefs() const
data.mContentBitmask = BackendTypeBit(BackendType::CAIRO);
#ifdef USE_SKIA
data.mCanvasBitmask |= BackendTypeBit(BackendType::SKIA);
data.mContentBitmask |= BackendTypeBit(BackendType::SKIA);
#endif
data.mCanvasDefault = BackendType::CAIRO;
data.mContentDefault = BackendType::CAIRO;
- return mozilla::Move(data);
+ return std::move(data);
}
void
gfxPlatform::InitBackendPrefs(BackendPrefsData&& aPrefsData)
{
mPreferredCanvasBackend = GetCanvasBackendPref(aPrefsData.mCanvasBitmask);
if (mPreferredCanvasBackend == BackendType::NONE) {
mPreferredCanvasBackend = aPrefsData.mCanvasDefault;
--- a/gfx/thebes/gfxPlatformMac.cpp
+++ b/gfx/thebes/gfxPlatformMac.cpp
@@ -98,17 +98,17 @@ gfxPlatformMac::GetBackendPrefs() const
{
BackendPrefsData data;
data.mCanvasBitmask = BackendTypeBit(BackendType::SKIA);
data.mContentBitmask = BackendTypeBit(BackendType::SKIA);
data.mCanvasDefault = BackendType::SKIA;
data.mContentDefault = BackendType::SKIA;
- return mozilla::Move(data);
+ return std::move(data);
}
bool
gfxPlatformMac::UsesTiling() const
{
// The non-tiling ContentClient requires CrossProcessSemaphore which
// isn't implemented for OSX.
return true;
--- a/gfx/thebes/gfxTextRun.cpp
+++ b/gfx/thebes/gfxTextRun.cpp
@@ -1369,17 +1369,17 @@ gfxTextRun::SortGlyphRuns()
return;
}
// We should never have an empty or one-element array here; if there's only
// one glyphrun, it should be stored directly in the textrun without using
// an array at all.
MOZ_ASSERT(mGlyphRunArray.Length() > 1);
- AutoTArray<GlyphRun,16> runs(Move(mGlyphRunArray));
+ AutoTArray<GlyphRun,16> runs(std::move(mGlyphRunArray));
GlyphRunOffsetComparator comp;
runs.Sort(comp);
// Now copy back, coalescing adjacent glyph runs that have the same font
mGlyphRunArray.Clear();
gfxFont* prevFont = nullptr;
gfx::ShapedTextFlags prevOrient = gfx::ShapedTextFlags();
DebugOnly<uint32_t> prevOffset = 0;
@@ -1394,17 +1394,17 @@ gfxTextRun::SortGlyphRuns()
MOZ_ASSERT(prevFont == nullptr ||
run.mCharacterOffset != prevOffset,
"Two fonts for the same run, glyph indices unreliable");
prevFont = run.mFont;
prevOrient = run.mOrientation;
#ifdef DEBUG
prevOffset = run.mCharacterOffset;
#endif
- if (!mGlyphRunArray.AppendElement(Move(run))) {
+ if (!mGlyphRunArray.AppendElement(std::move(run))) {
NS_WARNING("Failed to append glyph run!");
}
}
}
MOZ_ASSERT(mGlyphRunArray.Length() > 0);
if (mGlyphRunArray.Length() == 1) {
ConvertFromGlyphRunArray();
--- a/gfx/thebes/gfxTextRun.h
+++ b/gfx/thebes/gfxTextRun.h
@@ -804,28 +804,28 @@ private:
// the flag mHasGlyphRunArray tells us which is present.
union {
GlyphRun mSingleGlyphRun;
nsTArray<GlyphRun> mGlyphRunArray;
};
void ConvertToGlyphRunArray() {
MOZ_ASSERT(!mHasGlyphRunArray && mSingleGlyphRun.mFont);
- GlyphRun tmp = mozilla::Move(mSingleGlyphRun);
+ GlyphRun tmp = std::move(mSingleGlyphRun);
mSingleGlyphRun.~GlyphRun();
new (&mGlyphRunArray) nsTArray<GlyphRun>(2);
- mGlyphRunArray.AppendElement(mozilla::Move(tmp));
+ mGlyphRunArray.AppendElement(std::move(tmp));
mHasGlyphRunArray = true;
}
void ConvertFromGlyphRunArray() {
MOZ_ASSERT(mHasGlyphRunArray && mGlyphRunArray.Length() == 1);
- GlyphRun tmp = mozilla::Move(mGlyphRunArray[0]);
+ GlyphRun tmp = std::move(mGlyphRunArray[0]);
mGlyphRunArray.~nsTArray<GlyphRun>();
- new (&mSingleGlyphRun) GlyphRun(mozilla::Move(tmp));
+ new (&mSingleGlyphRun) GlyphRun(std::move(tmp));
mHasGlyphRunArray = false;
}
void *mUserData;
// mFontGroup is usually a strong reference, but refcounting is managed
// manually because it may be explicitly released by ReleaseFontGroup()
// in the case where the font group actually owns the textrun.
--- a/gfx/thebes/gfxUserFontSet.h
+++ b/gfx/thebes/gfxUserFontSet.h
@@ -389,20 +389,20 @@ public:
explicit Entry(KeyTypePointer aKey)
: mURI(aKey->mURI),
mPrincipal(aKey->mPrincipal),
mFontEntry(aKey->mFontEntry),
mPrivate(aKey->mPrivate)
{ }
Entry(Entry&& aOther)
- : mURI(mozilla::Move(aOther.mURI))
- , mPrincipal(mozilla::Move(aOther.mPrincipal))
- , mFontEntry(mozilla::Move(aOther.mFontEntry))
- , mPrivate(mozilla::Move(aOther.mPrivate))
+ : mURI(std::move(aOther.mURI))
+ , mPrincipal(std::move(aOther.mPrincipal))
+ , mFontEntry(std::move(aOther.mFontEntry))
+ , mPrivate(std::move(aOther.mPrivate))
{ }
~Entry() { }
bool KeyEquals(const KeyTypePointer aKey) const;
static KeyTypePointer KeyToPointer(KeyType aKey) { return &aKey; }
--- a/gfx/thebes/gfxWindowsPlatform.cpp
+++ b/gfx/thebes/gfxWindowsPlatform.cpp
@@ -446,17 +446,17 @@ gfxWindowsPlatform::GetBackendPrefs() co
data.mCanvasBitmask |= BackendTypeBit(BackendType::DIRECT2D1_1);
data.mCanvasDefault = BackendType::DIRECT2D1_1;
// We do not use d2d for content when WebRender is used.
if (!gfxVars::UseWebRender()) {
data.mContentBitmask |= BackendTypeBit(BackendType::DIRECT2D1_1);
data.mContentDefault = BackendType::DIRECT2D1_1;
}
}
- return mozilla::Move(data);
+ return std::move(data);
}
void
gfxWindowsPlatform::UpdateBackendPrefs()
{
BackendPrefsData data = GetBackendPrefs();
// Remove DIRECT2D1 preference if D2D1Device does not exist.
if (!Factory::HasD2D1Device()) {
@@ -464,17 +464,17 @@ gfxWindowsPlatform::UpdateBackendPrefs()
data.mContentBitmask &= ~BackendTypeBit(BackendType::DIRECT2D1_1);
if (data.mCanvasDefault == BackendType::DIRECT2D1_1) {
data.mCanvasDefault = BackendType::SKIA;
}
if (data.mContentDefault == BackendType::DIRECT2D1_1) {
data.mContentDefault = BackendType::SKIA;
}
}
- InitBackendPrefs(mozilla::Move(data));
+ InitBackendPrefs(std::move(data));
}
bool
gfxWindowsPlatform::IsDirect2DBackend()
{
return GetDefaultContentBackend() == BackendType::DIRECT2D1_1;
}
--- a/gfx/vr/VRThread.cpp
+++ b/gfx/vr/VRThread.cpp
@@ -170,31 +170,31 @@ const nsCOMPtr<nsIThread>
VRThread::GetThread() const
{
return mThread;
}
void
VRThread::PostTask(already_AddRefed<Runnable> aTask)
{
- PostDelayedTask(Move(aTask), 0);
+ PostDelayedTask(std::move(aTask), 0);
}
void
VRThread::PostDelayedTask(already_AddRefed<Runnable> aTask,
uint32_t aTime)
{
MOZ_ASSERT(mStarted, "Must call Start() before posting tasks.");
MOZ_ASSERT(mThread);
mLastActiveTime = TimeStamp::Now();
if (!aTime) {
- mThread->Dispatch(Move(aTask), NS_DISPATCH_NORMAL);
+ mThread->Dispatch(std::move(aTask), NS_DISPATCH_NORMAL);
} else {
- mThread->DelayedDispatch(Move(aTask), aTime);
+ mThread->DelayedDispatch(std::move(aTask), aTime);
}
}
void
VRThread::CheckLife(TimeStamp aCheckTimestamp)
{
// VR system is going to shutdown.
if (!mStarted) {
--- a/gfx/vr/ipc/VRManagerChild.cpp
+++ b/gfx/vr/ipc/VRManagerChild.cpp
@@ -98,17 +98,17 @@ VRManagerChild::InitForContent(Endpoint<
/* static */ bool
VRManagerChild::ReinitForContent(Endpoint<PVRManagerChild>&& aEndpoint)
{
MOZ_ASSERT(NS_IsMainThread());
ShutDown();
- return InitForContent(Move(aEndpoint));
+ return InitForContent(std::move(aEndpoint));
}
/*static*/ void
VRManagerChild::InitSameProcess()
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(!sVRManagerChildSingleton);
--- a/gfx/vr/ipc/VRManagerParent.cpp
+++ b/gfx/vr/ipc/VRManagerParent.cpp
@@ -87,17 +87,17 @@ VRManagerParent::CreateForContent(Endpoi
{
MessageLoop* loop = VRListenerThreadHolder::Loop();
RefPtr<VRManagerParent> vmp = new VRManagerParent(aEndpoint.OtherPid(), true);
loop->PostTask(NewRunnableMethod<Endpoint<PVRManagerParent>&&>(
"gfx::VRManagerParent::Bind",
vmp,
&VRManagerParent::Bind,
- Move(aEndpoint)));
+ std::move(aEndpoint)));
return true;
}
void
VRManagerParent::Bind(Endpoint<PVRManagerParent>&& aEndpoint)
{
if (!aEndpoint.Bind(this)) {
@@ -132,17 +132,17 @@ VRManagerParent::CreateForGPUProcess(End
MessageLoop* loop = VRListenerThreadHolder::Loop();
RefPtr<VRManagerParent> vmp = new VRManagerParent(aEndpoint.OtherPid(), false);
vmp->mVRListenerThreadHolder = VRListenerThreadHolder::GetSingleton();
loop->PostTask(NewRunnableMethod<Endpoint<PVRManagerParent>&&>(
"gfx::VRManagerParent::Bind",
vmp,
&VRManagerParent::Bind,
- Move(aEndpoint)));
+ std::move(aEndpoint)));
return true;
}
void
VRManagerParent::DeferredDestroy()
{
mVRListenerThreadHolder = nullptr;
mSelfRef = nullptr;
--- a/gfx/webrender_bindings/RenderCompositor.cpp
+++ b/gfx/webrender_bindings/RenderCompositor.cpp
@@ -19,20 +19,20 @@
namespace mozilla {
namespace wr {
/* static */ UniquePtr<RenderCompositor>
RenderCompositor::Create(RefPtr<widget::CompositorWidget>&& aWidget)
{
#ifdef XP_WIN
if (gfx::gfxVars::UseWebRenderANGLE()) {
- return RenderCompositorANGLE::Create(Move(aWidget));
+ return RenderCompositorANGLE::Create(std::move(aWidget));
}
#endif
- return RenderCompositorOGL::Create(Move(aWidget));
+ return RenderCompositorOGL::Create(std::move(aWidget));
}
RenderCompositor::RenderCompositor(RefPtr<widget::CompositorWidget>&& aWidget)
: mWidget(aWidget)
{
}
RenderCompositor::~RenderCompositor()
--- a/gfx/webrender_bindings/RenderCompositorANGLE.cpp
+++ b/gfx/webrender_bindings/RenderCompositorANGLE.cpp
@@ -25,25 +25,25 @@
#include <dxgi1_2.h>
namespace mozilla {
namespace wr {
/* static */ UniquePtr<RenderCompositor>
RenderCompositorANGLE::Create(RefPtr<widget::CompositorWidget>&& aWidget)
{
- UniquePtr<RenderCompositorANGLE> compositor = MakeUnique<RenderCompositorANGLE>(Move(aWidget));
+ UniquePtr<RenderCompositorANGLE> compositor = MakeUnique<RenderCompositorANGLE>(std::move(aWidget));
if (!compositor->Initialize()) {
return nullptr;
}
return compositor;
}
RenderCompositorANGLE::RenderCompositorANGLE(RefPtr<widget::CompositorWidget>&& aWidget)
- : RenderCompositor(Move(aWidget))
+ : RenderCompositor(std::move(aWidget))
, mEGLConfig(nullptr)
, mEGLSurface(nullptr)
{
}
RenderCompositorANGLE::~RenderCompositorANGLE()
{
DestroyEGLSurface();
--- a/gfx/webrender_bindings/RenderCompositorOGL.cpp
+++ b/gfx/webrender_bindings/RenderCompositorOGL.cpp
@@ -17,22 +17,22 @@ namespace wr {
RenderCompositorOGL::Create(RefPtr<widget::CompositorWidget>&& aWidget)
{
RefPtr<gl::GLContext> gl;
gl = gl::GLContextProvider::CreateForCompositorWidget(aWidget, true);
if (!gl || !gl->MakeCurrent()) {
gfxCriticalNote << "Failed GL context creation for WebRender: " << gfx::hexa(gl.get());
return nullptr;
}
- return MakeUnique<RenderCompositorOGL>(Move(gl), Move(aWidget));
+ return MakeUnique<RenderCompositorOGL>(std::move(gl), std::move(aWidget));
}
RenderCompositorOGL::RenderCompositorOGL(RefPtr<gl::GLContext>&& aGL,
RefPtr<widget::CompositorWidget>&& aWidget)
- : RenderCompositor(Move(aWidget))
+ : RenderCompositor(std::move(aWidget))
, mGL(aGL)
{
MOZ_ASSERT(mGL);
}
RenderCompositorOGL::~RenderCompositorOGL()
{
}
--- a/gfx/webrender_bindings/RenderThread.cpp
+++ b/gfx/webrender_bindings/RenderThread.cpp
@@ -131,17 +131,17 @@ void
RenderThread::AddRenderer(wr::WindowId aWindowId, UniquePtr<RendererOGL> aRenderer)
{
MOZ_ASSERT(IsInRenderThread());
if (mHasShutdown) {
return;
}
- mRenderers[aWindowId] = Move(aRenderer);
+ mRenderers[aWindowId] = std::move(aRenderer);
MutexAutoLock lock(mFrameCountMapLock);
mWindowInfos.Put(AsUint64(aWindowId), WindowInfo());
}
void
RenderThread::RemoveRenderer(wr::WindowId aWindowId)
{
@@ -228,17 +228,17 @@ RenderThread::RunEvent(wr::WindowId aWin
{
if (!IsInRenderThread()) {
Loop()->PostTask(
NewRunnableMethod<wr::WindowId, UniquePtr<RendererEvent>&&>(
"wr::RenderThread::RunEvent",
this,
&RenderThread::RunEvent,
aWindowId,
- Move(aEvent)));
+ std::move(aEvent)));
return;
}
aEvent->Run(*this, aWindowId);
aEvent = nullptr;
}
static void
@@ -450,17 +450,17 @@ void
RenderThread::RegisterExternalImage(uint64_t aExternalImageId, already_AddRefed<RenderTextureHost> aTexture)
{
MutexAutoLock lock(mRenderTextureMapLock);
if (mHasShutdown) {
return;
}
MOZ_ASSERT(!mRenderTextures.GetWeak(aExternalImageId));
- mRenderTextures.Put(aExternalImageId, Move(aTexture));
+ mRenderTextures.Put(aExternalImageId, std::move(aTexture));
}
void
RenderThread::UnregisterExternalImage(uint64_t aExternalImageId)
{
MutexAutoLock lock(mRenderTextureMapLock);
if (mHasShutdown) {
return;
@@ -473,17 +473,17 @@ RenderThread::UnregisterExternalImage(ui
// possible that RenderTextureHost is still exist after the shmem/raw buffer
// deletion. Then the buffer in RenderTextureHost becomes invalid. It's fine
// for this situation. Gecko will only release the buffer if WR doesn't need
// it. So, no one will access the invalid buffer in RenderTextureHost.
RefPtr<RenderTextureHost> texture;
mRenderTextures.Remove(aExternalImageId, getter_AddRefs(texture));
Loop()->PostTask(NewRunnableMethod<RefPtr<RenderTextureHost>>(
"RenderThread::DeferredRenderTextureHostDestroy",
- this, &RenderThread::DeferredRenderTextureHostDestroy, Move(texture)
+ this, &RenderThread::DeferredRenderTextureHostDestroy, std::move(texture)
));
} else {
mRenderTextures.Remove(aExternalImageId);
}
}
void
RenderThread::UnregisterExternalImageDuringShutdown(uint64_t aExternalImageId)
@@ -568,17 +568,17 @@ void wr_notifier_nop_frame_done(mozilla:
mozilla::wr::RenderThread::Get()->DecPendingFrameCount(aWindowId);
}
void wr_notifier_external_event(mozilla::wr::WrWindowId aWindowId, size_t aRawEvent)
{
mozilla::UniquePtr<mozilla::wr::RendererEvent> evt(
reinterpret_cast<mozilla::wr::RendererEvent*>(aRawEvent));
mozilla::wr::RenderThread::Get()->RunEvent(mozilla::wr::WindowId(aWindowId),
- mozilla::Move(evt));
+ std::move(evt));
}
void wr_schedule_render(mozilla::wr::WrWindowId aWindowId)
{
RefPtr<mozilla::layers::CompositorBridgeParent> cbp =
mozilla::layers::CompositorBridgeParent::GetCompositorBridgeParentFromWindowId(aWindowId);
if (cbp) {
cbp->ScheduleRenderOnCompositorThread();
--- a/gfx/webrender_bindings/RendererOGL.cpp
+++ b/gfx/webrender_bindings/RendererOGL.cpp
@@ -42,17 +42,17 @@ void UnlockExternalImage(void* aObj, wr:
}
RendererOGL::RendererOGL(RefPtr<RenderThread>&& aThread,
UniquePtr<RenderCompositor> aCompositor,
wr::WindowId aWindowId,
wr::Renderer* aRenderer,
layers::CompositorBridgeParent* aBridge)
: mThread(aThread)
- , mCompositor(Move(aCompositor))
+ , mCompositor(std::move(aCompositor))
, mRenderer(aRenderer)
, mBridge(aBridge)
, mWindowId(aWindowId)
, mDebugFlags({ 0 })
{
MOZ_ASSERT(mThread);
MOZ_ASSERT(mCompositor);
MOZ_ASSERT(mRenderer);
--- a/gfx/webrender_bindings/WebRenderAPI.cpp
+++ b/gfx/webrender_bindings/WebRenderAPI.cpp
@@ -34,34 +34,34 @@ public:
RefPtr<widget::CompositorWidget>&& aWidget,
layers::SynchronousTask* aTask,
LayoutDeviceIntSize aSize,
layers::SyncHandle* aHandle)
: mDocHandle(aDocHandle)
, mMaxTextureSize(aMaxTextureSize)
, mUseANGLE(aUseANGLE)
, mBridge(aBridge)
- , mCompositorWidget(Move(aWidget))
+ , mCompositorWidget(std::move(aWidget))
, mTask(aTask)
, mSize(aSize)
, mSyncHandle(aHandle)
{
MOZ_COUNT_CTOR(NewRenderer);
}
~NewRenderer()
{
MOZ_COUNT_DTOR(NewRenderer);
}
virtual void Run(RenderThread& aRenderThread, WindowId aWindowId) override
{
layers::AutoCompleteTask complete(mTask);
- UniquePtr<RenderCompositor> compositor = RenderCompositor::Create(Move(mCompositorWidget));
+ UniquePtr<RenderCompositor> compositor = RenderCompositor::Create(std::move(mCompositorWidget));
if (!compositor) {
// RenderCompositor::Create puts a message into gfxCriticalNote if it is nullptr
return;
}
*mUseANGLE = compositor->UseANGLE();
wr::Renderer* wrRenderer = nullptr;
@@ -70,18 +70,18 @@ public:
mDocHandle, &wrRenderer,
mMaxTextureSize)) {
// wr_window_new puts a message into gfxCriticalNote if it returns false
return;
}
MOZ_ASSERT(wrRenderer);
RefPtr<RenderThread> thread = &aRenderThread;
- auto renderer = MakeUnique<RendererOGL>(Move(thread),
- Move(compositor),
+ auto renderer = MakeUnique<RendererOGL>(std::move(thread),
+ std::move(compositor),
aWindowId,
wrRenderer,
mBridge);
if (wrRenderer && renderer) {
wr::WrExternalImageHandler handler = renderer->GetExternalImageHandler();
wr_renderer_set_external_image_handler(wrRenderer, &handler);
if (gfx::gfxVars::UseWebRenderProgramBinary()) {
wr_renderer_update_program_cache(wrRenderer, aRenderThread.ProgramCache()->Raw());
@@ -90,17 +90,17 @@ public:
if (renderer) {
layers::SyncObjectHost* syncObj = renderer->GetSyncObject();
if (syncObj) {
*mSyncHandle = syncObj->GetSyncHandle();
}
}
- aRenderThread.AddRenderer(aWindowId, Move(renderer));
+ aRenderThread.AddRenderer(aWindowId, std::move(renderer));
}
private:
wr::DocumentHandle** mDocHandle;
uint32_t* mMaxTextureSize;
bool* mUseANGLE;
layers::CompositorBridgeParent* mBridge;
RefPtr<widget::CompositorWidget> mCompositorWidget;
@@ -273,19 +273,19 @@ WebRenderAPI::Create(layers::CompositorB
bool useANGLE = false;
layers::SyncHandle syncHandle = 0;
// Dispatch a synchronous task because the DocumentHandle object needs to be created
// on the render thread. If need be we could delay waiting on this task until
// the next time we need to access the DocumentHandle object.
layers::SynchronousTask task("Create Renderer");
auto event = MakeUnique<NewRenderer>(&docHandle, aBridge, &maxTextureSize, &useANGLE,
- Move(aWidget), &task, aSize,
+ std::move(aWidget), &task, aSize,
&syncHandle);
- RenderThread::Get()->RunEvent(aWindowId, Move(event));
+ RenderThread::Get()->RunEvent(aWindowId, std::move(event));
task.Wait();
if (!docHandle) {
return nullptr;
}
return RefPtr<WebRenderAPI>(new WebRenderAPI(docHandle, aWindowId, maxTextureSize, useANGLE, syncHandle)).forget();
@@ -332,17 +332,17 @@ WebRenderAPI::~WebRenderAPI()
wr_api_delete_document(mDocHandle);
}
if (!mRootApi) {
RenderThread::Get()->SetDestroyed(GetId());
layers::SynchronousTask task("Destroy WebRenderAPI");
auto event = MakeUnique<RemoveRenderer>(&task);
- RunOnRenderThread(Move(event));
+ RunOnRenderThread(std::move(event));
task.Wait();
wr_api_shut_down(mDocHandle);
}
wr_api_delete(mDocHandle);
}
@@ -402,17 +402,17 @@ WebRenderAPI::Readback(gfx::IntSize size
};
layers::SynchronousTask task("Readback");
auto event = MakeUnique<Readback>(&task, size, buffer, buffer_size);
// This event will be passed from wr_backend thread to renderer thread. That
// implies that all frame data have been processed when the renderer runs this
// read-back event. Then, we could make sure this read-back event gets the
// latest result.
- RunOnRenderThread(Move(event));
+ RunOnRenderThread(std::move(event));
task.Wait();
}
void
WebRenderAPI::Pause()
{
class PauseEvent : public RendererEvent
@@ -437,17 +437,17 @@ WebRenderAPI::Pause()
layers::SynchronousTask* mTask;
};
layers::SynchronousTask task("Pause");
auto event = MakeUnique<PauseEvent>(&task);
// This event will be passed from wr_backend thread to renderer thread. That
// implies that all frame data have been processed when the renderer runs this event.
- RunOnRenderThread(Move(event));
+ RunOnRenderThread(std::move(event));
task.Wait();
}
bool
WebRenderAPI::Resume()
{
class ResumeEvent : public RendererEvent
@@ -475,17 +475,17 @@ WebRenderAPI::Resume()
bool* mResult;
};
bool result = false;
layers::SynchronousTask task("Resume");
auto event = MakeUnique<ResumeEvent>(&task, &result);
// This event will be passed from wr_backend thread to renderer thread. That
// implies that all frame data have been processed when the renderer runs this event.
- RunOnRenderThread(Move(event));
+ RunOnRenderThread(std::move(event));
task.Wait();
return result;
}
void
WebRenderAPI::WakeSceneBuilder()
{
@@ -522,17 +522,17 @@ WebRenderAPI::WaitFlushed()
layers::SynchronousTask* mTask;
};
layers::SynchronousTask task("WaitFlushed");
auto event = MakeUnique<WaitFlushedEvent>(&task);
// This event will be passed from wr_backend thread to renderer thread. That
// implies that all frame data have been processed when the renderer runs this event.
- RunOnRenderThread(Move(event));
+ RunOnRenderThread(std::move(event));
task.Wait();
}
void
WebRenderAPI::Capture()
{
uint8_t bits = 3; //TODO: get from JavaScript
@@ -702,17 +702,17 @@ public:
private:
TimeStamp mTime;
};
void
WebRenderAPI::SetFrameStartTime(const TimeStamp& aTime)
{
auto event = MakeUnique<FrameStartTime>(aTime);
- RunOnRenderThread(Move(event));
+ RunOnRenderThread(std::move(event));
}
void
WebRenderAPI::RunOnRenderThread(UniquePtr<RendererEvent> aEvent)
{
auto event = reinterpret_cast<uintptr_t>(aEvent.release());
wr_api_send_external_event(mDocHandle, event);
}
--- a/image/AnimationFrameBuffer.cpp
+++ b/image/AnimationFrameBuffer.cpp
@@ -80,41 +80,41 @@ AnimationFrameBuffer::Insert(RawAccessFr
if (mInsertIndex >= mFrames.Length()) {
mRedecodeError = true;
mPending = 0;
return false;
}
if (mInsertIndex > 0) {
MOZ_ASSERT(!mFrames[mInsertIndex]);
- mFrames[mInsertIndex] = Move(aFrame);
+ mFrames[mInsertIndex] = std::move(aFrame);
}
} else if (mInsertIndex == mFrames.Length()) {
// We are still on the first pass of the animation decoding, so this is
// the first time we have seen this frame.
- mFrames.AppendElement(Move(aFrame));
+ mFrames.AppendElement(std::move(aFrame));
if (mInsertIndex == mThreshold) {
// We just tripped over the threshold for the first time. This is our
// chance to do any clearing of already displayed frames. After this,
// we only need to release as we advance or force a restart.
MOZ_ASSERT(MayDiscard());
MOZ_ASSERT(mGetIndex < mInsertIndex);
for (size_t i = 1; i < mGetIndex; ++i) {
- RawAccessFrameRef discard = Move(mFrames[i]);
+ RawAccessFrameRef discard = std::move(mFrames[i]);
}
}
} else if (mInsertIndex > 0) {
// We were forced to restart an animation before we decoded the last
// frame. If we were discarding frames, then we tossed what we had
// except for the first frame.
MOZ_ASSERT(mInsertIndex < mFrames.Length());
MOZ_ASSERT(!mFrames[mInsertIndex]);
MOZ_ASSERT(MayDiscard());
- mFrames[mInsertIndex] = Move(aFrame);
+ mFrames[mInsertIndex] = std::move(aFrame);
} else { // mInsertIndex == 0
// We were forced to restart an animation before we decoded the last
// frame. We don't need the redecoded first frame because we always keep
// the original.
MOZ_ASSERT(MayDiscard());
}
MOZ_ASSERT(mFrames[mInsertIndex]);
@@ -243,20 +243,20 @@ AnimationFrameBuffer::AdvanceInternal()
MOZ_ASSERT(mFrames[mGetIndex]);
// If we moved forward, that means we can remove the previous frame, assuming
// that frame is not the first frame. If we looped and are back at the first
// frame, we can remove the last frame.
if (MayDiscard()) {
RawAccessFrameRef discard;
if (mGetIndex > 1) {
- discard = Move(mFrames[mGetIndex - 1]);
+ discard = std::move(mFrames[mGetIndex - 1]);
} else if (mGetIndex == 0) {
MOZ_ASSERT(mSizeKnown && framesLength > 1);
- discard = Move(mFrames[framesLength - 1]);
+ discard = std::move(mFrames[framesLength - 1]);
}
}
if (!mRedecodeError && (!mSizeKnown || MayDiscard())) {
// Calculate how many frames we have requested ahead of the current frame.
size_t buffered = mPending;
if (mGetIndex > mInsertIndex) {
// It wrapped around and we are decoding the beginning again before the
@@ -299,17 +299,17 @@ AnimationFrameBuffer::Reset()
// No need for us to restart it.
return false;
}
// Discard all frames besides the first, because the decoder always expects
// that when it re-inserts a frame, it is not present. (It doesn't re-insert
// the first frame.)
for (size_t i = 1; i < mFrames.Length(); ++i) {
- RawAccessFrameRef discard = Move(mFrames[i]);
+ RawAccessFrameRef discard = std::move(mFrames[i]);
}
mInsertIndex = 0;
// If we hit an error after redecoding, we never want to restart decoding.
if (mRedecodeError) {
MOZ_ASSERT(mPending == 0);
return false;
--- a/image/AnimationSurfaceProvider.cpp
+++ b/image/AnimationSurfaceProvider.cpp
@@ -306,17 +306,17 @@ AnimationSurfaceProvider::CheckForNewFra
return true;
}
// We should've gotten a different frame than last time.
MOZ_ASSERT_IF(!mFrames.Frames().IsEmpty(),
mFrames.Frames().LastElement().get() != frame.get());
// Append the new frame to the list.
- continueDecoding = mFrames.Insert(Move(frame));
+ continueDecoding = mFrames.Insert(std::move(frame));
// We only want to handle the first frame if it is the first pass for the
// animation decoder. The owning image will be cleared after that.
size_t frameCount = mFrames.Frames().Length();
if (frameCount == 1 && mImage) {
justGotFirstFrame = true;
}
}
@@ -356,17 +356,17 @@ AnimationSurfaceProvider::CheckForNewFra
}
if (!frame || (!mFrames.Frames().IsEmpty() &&
mFrames.Frames().LastElement().get() == frame.get())) {
return mFrames.MarkComplete();
}
// Append the new frame to the list.
- mFrames.Insert(Move(frame));
+ mFrames.Insert(std::move(frame));
continueDecoding = mFrames.MarkComplete();
// We only want to handle the first frame if it is the first pass for the
// animation decoder. The owning image will be cleared after that.
if (mFrames.Frames().Length() == 1 && mImage) {
justGotFirstFrame = true;
}
}
--- a/image/ClippedImage.cpp
+++ b/image/ClippedImage.cpp
@@ -279,17 +279,17 @@ ClippedImage::GetFrameInternal(const nsI
const Maybe<SVGImageContext>& aSVGContext,
uint32_t aWhichFrame,
uint32_t aFlags,
float aOpacity)
{
if (!ShouldClip()) {
RefPtr<SourceSurface> surface = InnerImage()->GetFrame(aWhichFrame, aFlags);
return MakePair(surface ? ImgDrawResult::SUCCESS : ImgDrawResult::NOT_READY,
- Move(surface));
+ std::move(surface));
}
float frameToDraw = InnerImage()->GetFrameIndex(aWhichFrame);
if (!mCachedSurface ||
!mCachedSurface->Matches(aSize, aSVGContext, frameToDraw, aFlags) ||
mCachedSurface->NeedsRedraw()) {
// Create a surface to draw into.
RefPtr<DrawTarget> target = gfxPlatform::GetPlatform()->
@@ -321,17 +321,17 @@ ClippedImage::GetFrameInternal(const nsI
mCachedSurface =
MakeUnique<ClippedImageCachedSurface>(target->Snapshot(), aSize, aSVGContext,
frameToDraw, aFlags,
drawTileCallback->GetDrawResult());
}
MOZ_ASSERT(mCachedSurface, "Should have a cached surface now");
RefPtr<SourceSurface> surface = mCachedSurface->Surface();
- return MakePair(mCachedSurface->GetDrawResult(), Move(surface));
+ return MakePair(mCachedSurface->GetDrawResult(), std::move(surface));
}
NS_IMETHODIMP_(bool)
ClippedImage::IsImageContainerAvailable(LayerManager* aManager, uint32_t aFlags)
{
if (!ShouldClip()) {
return InnerImage()->IsImageContainerAvailable(aManager, aFlags);
}
--- a/image/DecodePool.cpp
+++ b/image/DecodePool.cpp
@@ -133,19 +133,19 @@ public:
MonitorAutoLock lock(mMonitor);
if (mShuttingDown) {
// Drop any new work on the floor if we're shutting down.
return;
}
if (task->Priority() == TaskPriority::eHigh) {
- mHighPriorityQueue.AppendElement(Move(task));
+ mHighPriorityQueue.AppendElement(std::move(task));
} else {
- mLowPriorityQueue.AppendElement(Move(task));
+ mLowPriorityQueue.AppendElement(std::move(task));
}
// If there are pending tasks, create more workers if and only if we have
// not exceeded the capacity, and any previously created workers are ready.
if (mAvailableThreads) {
size_t pending = mHighPriorityQueue.Length() + mLowPriorityQueue.Length();
if (pending > mIdleThreads) {
CreateThread();
@@ -317,17 +317,17 @@ bool DecodePoolImpl::CreateThread()
nsresult rv = NS_NewNamedThread(mThreadNaming.GetNextThreadName("ImgDecoder"),
getter_AddRefs(thread), worker,
nsIThreadManager::kThreadPoolStackSize);
if (NS_FAILED(rv) || !thread) {
MOZ_ASSERT_UNREACHABLE("Should successfully create image decoding threads");
return false;
}
- mThreads.AppendElement(Move(thread));
+ mThreads.AppendElement(std::move(thread));
--mAvailableThreads;
++mIdleThreads;
MOZ_ASSERT(mIdleThreads <= mThreads.Capacity());
return true;
}
/* static */ void
DecodePool::Initialize()
--- a/image/Decoder.h
+++ b/image/Decoder.h
@@ -239,17 +239,17 @@ public:
* This must always be called before calling Init(). (And only before Init().)
*
* XXX(seth): We should eliminate this method and pass a SourceBufferIterator
* to the various decoder constructors instead.
*/
void SetIterator(SourceBufferIterator&& aIterator)
{
MOZ_ASSERT(!mInitialized, "Shouldn't be initialized yet");
- mIterator.emplace(Move(aIterator));
+ mIterator.emplace(std::move(aIterator));
}
SourceBuffer* GetSourceBuffer() const
{
return mIterator->Owner();
}
/**
--- a/image/FrameAnimator.cpp
+++ b/image/FrameAnimator.cpp
@@ -326,17 +326,17 @@ FrameAnimator::AdvanceFrame(AnimationSta
if (!DoBlend(aCurrentFrame, nextFrame, nextFrameIndex, &ret.mDirtyRect)) {
// something went wrong, move on to next
NS_WARNING("FrameAnimator::AdvanceFrame(): Compositing of frame failed");
nextFrame->SetCompositingFailed(true);
aState.mCurrentAnimationFrameTime =
GetCurrentImgFrameEndTime(aState, aCurrentFrame->GetTimeout());
aState.mCurrentAnimationFrameIndex = nextFrameIndex;
aState.mCompositedFrameRequested = false;
- aCurrentFrame = Move(nextFrame);
+ aCurrentFrame = std::move(nextFrame);
aFrames.Advance(nextFrameIndex);
return ret;
}
nextFrame->SetCompositingFailed(false);
}
@@ -373,17 +373,17 @@ FrameAnimator::AdvanceFrame(AnimationSta
aState.mLoopRemainingCount -= CheckedInt32(loops).value();
}
}
}
// Set currentAnimationFrameIndex at the last possible moment
aState.mCurrentAnimationFrameIndex = nextFrameIndex;
aState.mCompositedFrameRequested = false;
- aCurrentFrame = Move(nextFrame);
+ aCurrentFrame = std::move(nextFrame);
aFrames.Advance(nextFrameIndex);
// If we're here, we successfully advanced the frame.
ret.mFrameAdvanced = true;
return ret;
}
--- a/image/ISurfaceProvider.h
+++ b/image/ISurfaceProvider.h
@@ -150,38 +150,38 @@ private:
* sure that you want to draw it.
*/
class MOZ_STACK_CLASS DrawableSurface final
{
public:
DrawableSurface() : mHaveSurface(false) { }
explicit DrawableSurface(DrawableFrameRef&& aDrawableRef)
- : mDrawableRef(Move(aDrawableRef))
+ : mDrawableRef(std::move(aDrawableRef))
, mHaveSurface(bool(mDrawableRef))
{ }
explicit DrawableSurface(NotNull<ISurfaceProvider*> aProvider)
: mProvider(aProvider)
, mHaveSurface(true)
{ }
DrawableSurface(DrawableSurface&& aOther)
- : mDrawableRef(Move(aOther.mDrawableRef))
- , mProvider(Move(aOther.mProvider))
+ : mDrawableRef(std::move(aOther.mDrawableRef))
+ , mProvider(std::move(aOther.mProvider))
, mHaveSurface(aOther.mHaveSurface)
{
aOther.mHaveSurface = false;
}
DrawableSurface& operator=(DrawableSurface&& aOther)
{
MOZ_ASSERT(this != &aOther, "Self-moves are prohibited");
- mDrawableRef = Move(aOther.mDrawableRef);
- mProvider = Move(aOther.mProvider);
+ mDrawableRef = std::move(aOther.mDrawableRef);
+ mProvider = std::move(aOther.mProvider);
mHaveSurface = aOther.mHaveSurface;
aOther.mHaveSurface = false;
return *this;
}
/**
* If this DrawableSurface is dynamically generated from an animation, attempt
* to seek to frame @aFrame, where @aFrame is a 0-based index into the frames
--- a/image/ImageCacheKey.cpp
+++ b/image/ImageCacheKey.cpp
@@ -88,18 +88,18 @@ ImageCacheKey::ImageCacheKey(const Image
, mBlobSerial(aOther.mBlobSerial)
, mOriginAttributes(aOther.mOriginAttributes)
, mControlledDocument(aOther.mControlledDocument)
, mHash(aOther.mHash)
, mIsChrome(aOther.mIsChrome)
{ }
ImageCacheKey::ImageCacheKey(ImageCacheKey&& aOther)
- : mURI(Move(aOther.mURI))
- , mBlobSerial(Move(aOther.mBlobSerial))
+ : mURI(std::move(aOther.mURI))
+ , mBlobSerial(std::move(aOther.mBlobSerial))
, mOriginAttributes(aOther.mOriginAttributes)
, mControlledDocument(aOther.mControlledDocument)
, mHash(aOther.mHash)
, mIsChrome(aOther.mIsChrome)
{ }
bool
ImageCacheKey::operator==(const ImageCacheKey& aOther) const
--- a/image/ImageOps.cpp
+++ b/image/ImageOps.cpp
@@ -96,17 +96,17 @@ protected:
private:
RefPtr<SourceBuffer> mSourceBuffer;
};
/* static */ already_AddRefed<ImageOps::ImageBuffer>
ImageOps::CreateImageBuffer(already_AddRefed<nsIInputStream> aInputStream)
{
- nsCOMPtr<nsIInputStream> inputStream = Move(aInputStream);
+ nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream);
MOZ_ASSERT(inputStream);
nsresult rv;
// Prepare the input stream.
if (!NS_InputStreamIsBuffered(inputStream)) {
nsCOMPtr<nsIInputStream> bufStream;
rv = NS_NewBufferedInputStream(getter_AddRefs(bufStream),
@@ -143,17 +143,17 @@ ImageOps::CreateImageBuffer(already_AddR
return imageBuffer.forget();
}
/* static */ nsresult
ImageOps::DecodeMetadata(already_AddRefed<nsIInputStream> aInputStream,
const nsACString& aMimeType,
ImageMetadata& aMetadata)
{
- nsCOMPtr<nsIInputStream> inputStream = Move(aInputStream);
+ nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream);
RefPtr<ImageBuffer> buffer = CreateImageBuffer(inputStream.forget());
return DecodeMetadata(buffer, aMimeType, aMetadata);
}
/* static */ nsresult
ImageOps::DecodeMetadata(ImageBuffer* aBuffer,
const nsACString& aMimeType,
ImageMetadata& aMetadata)
@@ -193,17 +193,17 @@ ImageOps::DecodeMetadata(ImageBuffer* aB
}
/* static */ already_AddRefed<gfx::SourceSurface>
ImageOps::DecodeToSurface(already_AddRefed<nsIInputStream> aInputStream,
const nsACString& aMimeType,
uint32_t aFlags,
const Maybe<IntSize>& aSize /* = Nothing() */)
{
- nsCOMPtr<nsIInputStream> inputStream = Move(aInputStream);
+ nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream);
RefPtr<ImageBuffer> buffer = CreateImageBuffer(inputStream.forget());
return DecodeToSurface(buffer, aMimeType, aFlags, aSize);
}
/* static */ already_AddRefed<gfx::SourceSurface>
ImageOps::DecodeToSurface(ImageBuffer* aBuffer,
const nsACString& aMimeType,
uint32_t aFlags,
--- a/image/LookupResult.h
+++ b/image/LookupResult.h
@@ -47,51 +47,51 @@ public:
: mMatchType(aMatchType)
{
MOZ_ASSERT(mMatchType == MatchType::NOT_FOUND ||
mMatchType == MatchType::PENDING,
"Only NOT_FOUND or PENDING make sense with no surface");
}
LookupResult(LookupResult&& aOther)
- : mSurface(Move(aOther.mSurface))
+ : mSurface(std::move(aOther.mSurface))
, mMatchType(aOther.mMatchType)
, mSuggestedSize(aOther.mSuggestedSize)
{ }
LookupResult(DrawableSurface&& aSurface, MatchType aMatchType)
- : mSurface(Move(aSurface))
+ : mSurface(std::move(aSurface))
, mMatchType(aMatchType)
{
MOZ_ASSERT(!mSurface || !(mMatchType == MatchType::NOT_FOUND ||
mMatchType == MatchType::PENDING),
"Only NOT_FOUND or PENDING make sense with no surface");
MOZ_ASSERT(mSurface || mMatchType == MatchType::NOT_FOUND ||
mMatchType == MatchType::PENDING,
"NOT_FOUND or PENDING do not make sense with a surface");
}
LookupResult(DrawableSurface&& aSurface, MatchType aMatchType,
const gfx::IntSize& aSuggestedSize)
- : mSurface(Move(aSurface))
+ : mSurface(std::move(aSurface))
, mMatchType(aMatchType)
, mSuggestedSize(aSuggestedSize)
{
MOZ_ASSERT(!mSurface || !(mMatchType == MatchType::NOT_FOUND ||
mMatchType == MatchType::PENDING),
"Only NOT_FOUND or PENDING make sense with no surface");
MOZ_ASSERT(mSurface || mMatchType == MatchType::NOT_FOUND ||
mMatchType == MatchType::PENDING,
"NOT_FOUND or PENDING do not make sense with a surface");
}
LookupResult& operator=(LookupResult&& aOther)
{
MOZ_ASSERT(&aOther != this, "Self-move-assignment is not supported");
- mSurface = Move(aOther.mSurface);
+ mSurface = std::move(aOther.mSurface);
mMatchType = aOther.mMatchType;
mSuggestedSize = aOther.mSuggestedSize;
return *this;
}
DrawableSurface& Surface() { return mSurface; }
const DrawableSurface& Surface() const { return mSurface; }
const gfx::IntSize& SuggestedSize() const { return mSuggestedSize; }
--- a/image/RasterImage.cpp
+++ b/image/RasterImage.cpp
@@ -383,17 +383,17 @@ RasterImage::LookupFrame(const IntSize&
}
if (!result) {
// We still weren't able to get a frame. Give up.
return result;
}
if (result.Surface()->GetCompositingFailed()) {
- DrawableSurface tmp = Move(result.Surface());
+ DrawableSurface tmp = std::move(result.Surface());
return result;
}
MOZ_ASSERT(!result.Surface()->GetIsPaletted(),
"Should not have a paletted frame");
// Sync decoding guarantees that we got the frame, but if it's owned by an
// async decoder that's currently running, the contents of the frame may not
@@ -403,17 +403,17 @@ RasterImage::LookupFrame(const IntSize&
}
// If we could have done some decoding in this function we need to check if
// that decoding encountered an error and hence aborted the surface. We want
// to avoid calling IsAborted if we weren't passed any sync decode flag because
// IsAborted acquires the monitor for the imgFrame.
if (aFlags & (FLAG_SYNC_DECODE | FLAG_SYNC_DECODE_IF_FAST) &&
result.Surface()->IsAborted()) {
- DrawableSurface tmp = Move(result.Surface());
+ DrawableSurface tmp = std::move(result.Surface());
return result;
}
return result;
}
bool
RasterImage::IsOpaque()
@@ -618,20 +618,20 @@ RasterImage::GetFrameInternal(const IntS
if (!result) {
// The OS threw this frame away and we couldn't redecode it.
return MakeTuple(ImgDrawResult::TEMPORARY_ERROR, suggestedSize,
RefPtr<SourceSurface>());
}
RefPtr<SourceSurface> surface = result.Surface()->GetSourceSurface();
if (!result.Surface()->IsFinished()) {
- return MakeTuple(ImgDrawResult::INCOMPLETE, suggestedSize, Move(surface));
+ return MakeTuple(ImgDrawResult::INCOMPLETE, suggestedSize, std::move(surface));
}
- return MakeTuple(ImgDrawResult::SUCCESS, suggestedSize, Move(surface));
+ return MakeTuple(ImgDrawResult::SUCCESS, suggestedSize, std::move(surface));
}
IntSize
RasterImage::GetImageContainerSize(LayerManager* aManager,
const IntSize& aSize,
uint32_t aFlags)
{
if (!IsImageContainerAvailableAtSize(aManager, aSize, aFlags)) {
@@ -1174,17 +1174,17 @@ RasterImage::RequestDecodeForSizeInterna
uint32_t flags = shouldSyncDecodeIfFast
? aFlags
: aFlags & ~FLAG_SYNC_DECODE_IF_FAST;
// Perform a frame lookup, which will implicitly start decoding if needed.
PlaybackType playbackType = mAnimationState ? PlaybackType::eAnimated
: PlaybackType::eStatic;
LookupResult result = LookupFrame(aSize, flags, playbackType);
- return Move(result.Surface());
+ return std::move(result.Surface());
}
static bool
LaunchDecodingTask(IDecodingTask* aTask,
RasterImage* aImage,
uint32_t aFlags,
bool aHaveSourceData)
{
@@ -1499,17 +1499,17 @@ RasterImage::Draw(gfxContext* aContext,
mDrawStartTime = TimeStamp::Now();
}
return ImgDrawResult::NOT_READY;
}
bool shouldRecordTelemetry = !mDrawStartTime.IsNull() &&
result.Surface()->IsFinished();
- auto drawResult = DrawInternal(Move(result.Surface()), aContext, aSize,
+ auto drawResult = DrawInternal(std::move(result.Surface()), aContext, aSize,
aRegion, aSamplingFilter, flags, aOpacity);
if (shouldRecordTelemetry) {
TimeDuration drawLatency = TimeStamp::Now() - mDrawStartTime;
Telemetry::Accumulate(Telemetry::IMAGE_DECODE_ON_DRAW_LATENCY,
int32_t(drawLatency.ToMicroseconds()));
if (mAnimationState) {
Telemetry::Accumulate(Telemetry::IMAGE_ANIMATED_DECODE_ON_DRAW_LATENCY,
--- a/image/SourceBuffer.cpp
+++ b/image/SourceBuffer.cpp
@@ -32,17 +32,17 @@ SourceBufferIterator::~SourceBufferItera
SourceBufferIterator&
SourceBufferIterator::operator=(SourceBufferIterator&& aOther)
{
if (mOwner) {
mOwner->OnIteratorRelease();
}
- mOwner = Move(aOther.mOwner);
+ mOwner = std::move(aOther.mOwner);
mState = aOther.mState;
mData = aOther.mData;
mChunkCount = aOther.mChunkCount;
mByteCount = aOther.mByteCount;
mRemainderToRead = aOther.mRemainderToRead;
return *this;
}
@@ -154,17 +154,17 @@ SourceBuffer::AppendChunk(Maybe<Chunk>&&
if (MOZ_UNLIKELY(!aChunk)) {
return NS_ERROR_OUT_OF_MEMORY;
}
if (MOZ_UNLIKELY(aChunk->AllocationFailed())) {
return NS_ERROR_OUT_OF_MEMORY;
}
- if (MOZ_UNLIKELY(!mChunks.AppendElement(Move(*aChunk), fallible))) {
+ if (MOZ_UNLIKELY(!mChunks.AppendElement(std::move(*aChunk), fallible))) {
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
Maybe<SourceBuffer::Chunk>
SourceBuffer::CreateChunk(size_t aCapacity,
@@ -458,17 +458,17 @@ SourceBuffer::Append(const char* aData,
currentChunk.AddLength(forCurrentChunk);
// If we created a new chunk, add it to the series.
if (forNextChunk > 0) {
if (MOZ_UNLIKELY(!nextChunk)) {
return HandleError(NS_ERROR_OUT_OF_MEMORY);
}
- if (MOZ_UNLIKELY(NS_FAILED(AppendChunk(Move(nextChunk))))) {
+ if (MOZ_UNLIKELY(NS_FAILED(AppendChunk(std::move(nextChunk))))) {
return HandleError(NS_ERROR_OUT_OF_MEMORY);
}
}
// Resume any waiting readers now that there's new data.
ResumeWaitingConsumers();
}
--- a/image/SourceBuffer.h
+++ b/image/SourceBuffer.h
@@ -88,17 +88,17 @@ public:
mData.mIterating.mChunk = 0;
mData.mIterating.mData = nullptr;
mData.mIterating.mOffset = 0;
mData.mIterating.mAvailableLength = 0;
mData.mIterating.mNextReadLength = 0;
}
SourceBufferIterator(SourceBufferIterator&& aOther)
- : mOwner(Move(aOther.mOwner))
+ : mOwner(std::move(aOther.mOwner))
, mState(aOther.mState)
, mData(aOther.mData)
, mChunkCount(aOther.mChunkCount)
, mByteCount(aOther.mByteCount)
, mRemainderToRead(aOther.mRemainderToRead)
{ }
~SourceBufferIterator();
--- a/image/StreamingLexer.h
+++ b/image/StreamingLexer.h
@@ -443,17 +443,17 @@ public:
// Force the data pointer to be where we expect it to be.
state = other.Advance(0);
if (state != SourceBufferIterator::READY) {
// The current position could be the end of the buffer, in which case
// there is no point cloning with no more data to read.
MOZ_ASSERT(state == SourceBufferIterator::COMPLETE);
return Nothing();
}
- return Some(Move(other));
+ return Some(std::move(other));
}
template <typename Func>
LexerResult Lex(SourceBufferIterator& aIterator,
IResumable* aOnResume,
Func aFunc)
{
if (mTransition.NextStateIsTerminal()) {
@@ -679,17 +679,17 @@ private:
{
MOZ_ASSERT(mTransition.Buffering() == BufferingStrategy::BUFFERED);
MOZ_ASSERT(mYieldingToState);
MOZ_ASSERT(!mUnbufferedState,
"Buffered read at the same time as unbuffered read?");
MOZ_ASSERT(mBuffer.length() <= mTransition.Size(),
"Buffered more than we needed?");
- State nextState = Move(*mYieldingToState);
+ State nextState = std::move(*mYieldingToState);
// After a yield, we need to take the same data that we delivered to the
// last state, and deliver it again to the new state. We know that this is
// happening right at a state transition, and that the last state was a
// buffered read, so there are two cases:
// 1. We got the data from the SourceBufferIterator directly.
if (mBuffer.empty() && aIterator.Length() == mTransition.Size()) {
--- a/image/SurfaceCache.cpp
+++ b/image/SurfaceCache.cpp
@@ -919,17 +919,17 @@ public:
if (aMarkUsed &&
!MarkUsed(WrapNotNull(surface), WrapNotNull(cache), aAutoLock)) {
Remove(WrapNotNull(surface), /* aStopTracking */ false, aAutoLock);
return LookupResult(MatchType::NOT_FOUND);
}
MOZ_ASSERT(surface->GetSurfaceKey() == aSurfaceKey,
"Lookup() not returning an exact match?");
- return LookupResult(Move(drawableSurface), MatchType::EXACT);
+ return LookupResult(std::move(drawableSurface), MatchType::EXACT);
}
LookupResult LookupBestMatch(const ImageKey aImageKey,
const SurfaceKey& aSurfaceKey,
const StaticMutexAutoLock& aAutoLock)
{
RefPtr<ImageSurfaceCache> cache = GetImageCache(aImageKey);
if (!cache) {
@@ -975,17 +975,17 @@ public:
if (matchType == MatchType::EXACT ||
matchType == MatchType::SUBSTITUTE_BECAUSE_BEST) {
if (!MarkUsed(WrapNotNull(surface), WrapNotNull(cache), aAutoLock)) {
Remove(WrapNotNull(surface), /* aStopTracking */ false, aAutoLock);
}
}
- return LookupResult(Move(drawableSurface), matchType, suggestedSize);
+ return LookupResult(std::move(drawableSurface), matchType, suggestedSize);
}
bool CanHold(const Cost aCost) const
{
return aCost <= mMaxCost;
}
size_t MaximumCapacity() const
@@ -1126,17 +1126,17 @@ public:
Remove(mCosts.LastElement().Surface(), /* aStopTracking */ true, aAutoLock);
}
}
void TakeDiscard(nsTArray<RefPtr<CachedSurface>>& aDiscard,
const StaticMutexAutoLock& aAutoLock)
{
MOZ_ASSERT(aDiscard.IsEmpty());
- aDiscard = Move(mCachedSurfacesDiscard);
+ aDiscard = std::move(mCachedSurfacesDiscard);
}
void LockSurface(NotNull<CachedSurface*> aSurface,
const StaticMutexAutoLock& aAutoLock)
{
if (aSurface->IsPlaceholder() || aSurface->IsLocked()) {
return;
}
@@ -1316,17 +1316,17 @@ private:
void NotifyHandlerEndLocked(const StaticMutexAutoLock& aAutoLock) override
{
sInstance->TakeDiscard(mDiscard, aAutoLock);
}
void NotifyHandlerEnd() override
{
- nsTArray<RefPtr<CachedSurface>> discard(Move(mDiscard));
+ nsTArray<RefPtr<CachedSurface>> discard(std::move(mDiscard));
}
StaticMutex& GetMutex() override
{
return sInstanceMutex;
}
nsTArray<RefPtr<CachedSurface>> mDiscard;
--- a/image/SurfacePipe.h
+++ b/image/SurfacePipe.h
@@ -604,26 +604,26 @@ private:
*/
class SurfacePipe
{
public:
SurfacePipe()
{ }
SurfacePipe(SurfacePipe&& aOther)
- : mHead(Move(aOther.mHead))
+ : mHead(std::move(aOther.mHead))
{ }
~SurfacePipe()
{ }
SurfacePipe& operator=(SurfacePipe&& aOther)
{
MOZ_ASSERT(this != &aOther);
- mHead = Move(aOther.mHead);
+ mHead = std::move(aOther.mHead);
return *this;
}
/// Begins a new pass, seeking to the first row of the surface.
void ResetToFirstRow()
{
MOZ_ASSERT(mHead, "Use before configured!");
mHead->ResetToFirstRow();
@@ -727,17 +727,17 @@ public:
return mHead->TakeInvalidRect();
}
private:
friend class SurfacePipeFactory;
friend class TestSurfacePipeFactory;
explicit SurfacePipe(UniquePtr<SurfaceFilter>&& aHead)
- : mHead(Move(aHead))
+ : mHead(std::move(aHead))
{ }
SurfacePipe(const SurfacePipe&) = delete;
SurfacePipe& operator=(const SurfacePipe&) = delete;
UniquePtr<SurfaceFilter> mHead; /// The first filter in the chain.
};
--- a/image/SurfacePipeFactory.h
+++ b/image/SurfacePipeFactory.h
@@ -230,17 +230,17 @@ private:
MakePipe(const Configs&... aConfigs)
{
auto pipe = MakeUnique<typename detail::FilterPipeline<Configs...>::Type>();
nsresult rv = pipe->Configure(aConfigs...);
if (NS_FAILED(rv)) {
return Nothing();
}
- return Some(SurfacePipe { Move(pipe) } );
+ return Some(SurfacePipe { std::move(pipe) } );
}
virtual ~SurfacePipeFactory() = 0;
};
} // namespace image
} // namespace mozilla
--- a/image/VectorImage.cpp
+++ b/image/VectorImage.cpp
@@ -804,17 +804,17 @@ VectorImage::GetFrameInternal(const IntS
if (!mIsFullyLoaded) {
return MakeTuple(ImgDrawResult::NOT_READY, aSize,
RefPtr<SourceSurface>());
}
RefPtr<SourceSurface> sourceSurface =
LookupCachedSurface(aSize, aSVGContext, aFlags);
if (sourceSurface) {
- return MakeTuple(ImgDrawResult::SUCCESS, aSize, Move(sourceSurface));
+ return MakeTuple(ImgDrawResult::SUCCESS, aSize, std::move(sourceSurface));
}
if (mIsDrawing) {
NS_WARNING("Refusing to make re-entrant call to VectorImage::Draw");
return MakeTuple(ImgDrawResult::TEMPORARY_ERROR, aSize,
RefPtr<SourceSurface>());
}
@@ -839,17 +839,17 @@ VectorImage::GetFrameInternal(const IntS
CreateSurface(params, svgDrawable, didCache);
if (!surface) {
MOZ_ASSERT(!didCache);
return MakeTuple(ImgDrawResult::TEMPORARY_ERROR, aSize,
RefPtr<SourceSurface>());
}
SendFrameComplete(didCache, params.flags);
- return MakeTuple(ImgDrawResult::SUCCESS, aSize, Move(surface));
+ return MakeTuple(ImgDrawResult::SUCCESS, aSize, std::move(surface));
}
//******************************************************************************
IntSize
VectorImage::GetImageContainerSize(LayerManager* aManager,
const IntSize& aSize,
uint32_t aFlags)
{
--- a/image/decoders/nsGIFDecoder2.cpp
+++ b/image/decoders/nsGIFDecoder2.cpp
@@ -226,17 +226,17 @@ nsGIFDecoder2::BeginImageFrame(const Int
mCurrentFrameIndex = mGIFStruct.images_decoded;
if (!pipe) {
mPipe = SurfacePipe();
return NS_ERROR_FAILURE;
}
- mPipe = Move(*pipe);
+ mPipe = std::move(*pipe);
return NS_OK;
}
//******************************************************************************
void
nsGIFDecoder2::EndImageFrame()
{
--- a/image/decoders/nsICODecoder.cpp
+++ b/image/decoders/nsICODecoder.cpp
@@ -198,17 +198,17 @@ LexerTransition<ICOState>
nsICODecoder::IterateUnsizedDirEntry()
{
MOZ_ASSERT(!mUnsizedDirEntries.IsEmpty());
if (!mDirEntry) {
// The first time we are here, there is no entry selected. We must prepare a
// new iterator for the contained decoder to advance as it wills. Cloning at
// this point ensures it will begin at the end of the dir entries.
- mReturnIterator = Move(mLexer.Clone(*mIterator, SIZE_MAX));
+ mReturnIterator = std::move(mLexer.Clone(*mIterator, SIZE_MAX));
if (mReturnIterator.isNothing()) {
// If we cannot read further than this point, then there is no resource
// data to read.
return Transition::TerminateFailure();
}
} else {
// We have already selected an entry which means a metadata decoder has
// finished. Verify the size is valid and if so, add to the discovered
@@ -218,17 +218,17 @@ nsICODecoder::IterateUnsizedDirEntry()
}
// Remove the entry from the unsized list either way.
mDirEntry = nullptr;
mUnsizedDirEntries.RemoveElementAt(0);
// Our iterator is at an unknown point, so reset it to the point that we
// saved.
- mIterator = Move(mLexer.Clone(*mReturnIterator, SIZE_MAX));
+ mIterator = std::move(mLexer.Clone(*mReturnIterator, SIZE_MAX));
if (mIterator.isNothing()) {
MOZ_ASSERT_UNREACHABLE("Cannot re-clone return iterator");
return Transition::TerminateFailure();
}
}
// There are no more unsized entries, so we can finally decide which entry to
// select for decoding.
@@ -368,17 +368,17 @@ nsICODecoder::SniffResource(const char*
}
// Create a PNG decoder which will do the rest of the work for us.
bool metadataDecode = mReturnIterator.isSome();
Maybe<IntSize> expectedSize = metadataDecode ? Nothing()
: Some(mDirEntry->mSize);
mContainedDecoder =
DecoderFactory::CreateDecoderForICOResource(DecoderType::PNG,
- Move(containedIterator.ref()),
+ std::move(containedIterator.ref()),
WrapNotNull(this),
metadataDecode,
expectedSize);
// Read in the rest of the PNG unbuffered.
size_t toRead = mDirEntry->mBytesInRes - BITMAPINFOSIZE;
return Transition::ToUnbuffered(ICOState::FINISHED_RESOURCE,
ICOState::READ_RESOURCE,
@@ -439,17 +439,17 @@ nsICODecoder::ReadBIH(const char* aData)
// Create a BMP decoder which will do most of the work for us; the exception
// is the AND mask, which isn't present in standalone BMPs.
bool metadataDecode = mReturnIterator.isSome();
Maybe<IntSize> expectedSize = metadataDecode ? Nothing()
: Some(mDirEntry->mSize);
mContainedDecoder =
DecoderFactory::CreateDecoderForICOResource(DecoderType::BMP,
- Move(containedIterator.ref()),
+ std::move(containedIterator.ref()),
WrapNotNull(this),
metadataDecode,
expectedSize,
Some(dataOffset));
RefPtr<nsBMPDecoder> bmpDecoder =
static_cast<nsBMPDecoder*>(mContainedDecoder.get());
--- a/image/decoders/nsIconDecoder.cpp
+++ b/image/decoders/nsIconDecoder.cpp
@@ -73,17 +73,17 @@ nsIconDecoder::ReadHeader(const char* aD
SurfacePipeFactory::CreateSurfacePipe(this, Size(), OutputSize(),
FullFrame(), SurfaceFormat::B8G8R8A8,
/* aAnimParams */ Nothing(),
SurfacePipeFlags());
if (!pipe) {
return Transition::TerminateFailure();
}
- mPipe = Move(*pipe);
+ mPipe = std::move(*pipe);
MOZ_ASSERT(mImageData, "Should have a buffer now");
return Transition::To(State::ROW_OF_PIXELS, mBytesPerRow);
}
LexerTransition<nsIconDecoder::State>
nsIconDecoder::ReadRowOfPixels(const char* aData, size_t aLength)
--- a/image/decoders/nsPNGDecoder.cpp
+++ b/image/decoders/nsPNGDecoder.cpp
@@ -238,17 +238,17 @@ nsPNGDecoder::CreateFrame(const FrameInf
aFrameInfo.mFrameRect, mFormat,
animParams, pipeFlags);
if (!pipe) {
mPipe = SurfacePipe();
return NS_ERROR_FAILURE;
}
- mPipe = Move(*pipe);
+ mPipe = std::move(*pipe);
mFrameRect = aFrameInfo.mFrameRect;
mPass = 0;
MOZ_LOG(sPNGDecoderAccountingLog, LogLevel::Debug,
("PNGDecoderAccounting: nsPNGDecoder::CreateFrame -- created "
"image frame with %dx%d pixels for decoder %p",
mFrameRect.Width(), mFrameRect.Height(), this));
--- a/image/imgFrame.h
+++ b/image/imgFrame.h
@@ -347,24 +347,24 @@ public:
}
} else {
MOZ_ASSERT(aFrame->mOptSurface);
}
}
DrawableFrameRef(DrawableFrameRef&& aOther)
: mFrame(aOther.mFrame.forget())
- , mRef(Move(aOther.mRef))
+ , mRef(std::move(aOther.mRef))
{ }
DrawableFrameRef& operator=(DrawableFrameRef&& aOther)
{
MOZ_ASSERT(this != &aOther, "Self-moves are prohibited");
mFrame = aOther.mFrame.forget();
- mRef = Move(aOther.mRef);
+ mRef = std::move(aOther.mRef);
return *this;
}
explicit operator bool() const { return bool(mFrame); }
imgFrame* operator->()
{
MOZ_ASSERT(mFrame);
--- a/image/imgLoader.cpp
+++ b/image/imgLoader.cpp
@@ -462,17 +462,17 @@ private:
RefPtr<image::Image> image = aRequest->GetImage();
if (!image) {
return;
}
SizeOfState state(ImagesMallocSizeOf);
ImageMemoryCounter counter(image, state, aIsUsed);
- aArray->AppendElement(Move(counter));
+ aArray->AppendElement(std::move(counter));
}
};
NS_IMPL_ISUPPORTS(imgMemoryReporter, nsIMemoryReporter)
NS_IMPL_ISUPPORTS(nsProgressNotificationProxy,
nsIProgressEventSink,
nsIChannelEventSink,
@@ -1062,17 +1062,17 @@ imgCacheQueue::Remove(imgCacheEntry* ent
}
void
imgCacheQueue::Push(imgCacheEntry* entry)
{
mSize += entry->GetDataSize();
RefPtr<imgCacheEntry> refptr(entry);
- mQueue.AppendElement(Move(refptr));
+ mQueue.AppendElement(std::move(refptr));
// If we're not dirty already, then we can efficiently add this to the
// binary heap immediately. This is only O(log n).
if (!IsDirty()) {
std::push_heap(mQueue.begin(), mQueue.end(), imgLoader::CompareCacheEntries);
}
}
already_AddRefed<imgCacheEntry>
@@ -2978,17 +2978,17 @@ imgCacheValidator::UpdateProxies(bool aC
}
// We have finished validating the request, so we can safely take ownership
// of the proxy list. imgRequestProxy::SyncNotifyListener can mutate the list
// if imgRequestProxy::CancelAndForgetObserver is called by its owner. Note
// that any potential notifications should still be suppressed in
// imgRequestProxy::ChangeOwner because we haven't cleared the validating
// flag yet, and thus they will remain deferred.
- AutoTArray<RefPtr<imgRequestProxy>, 4> proxies(Move(mProxies));
+ AutoTArray<RefPtr<imgRequestProxy>, 4> proxies(std::move(mProxies));
for (auto& proxy : proxies) {
// First update the state of all proxies before notifying any of them
// to ensure a consistent state (e.g. in case the notification causes
// other proxies to be touched indirectly.)
MOZ_ASSERT(proxy->IsValidating());
MOZ_ASSERT(proxy->NotificationsDeferred(),
"Proxies waiting on cache validation should be "
--- a/image/imgRequest.cpp
+++ b/image/imgRequest.cpp
@@ -1182,17 +1182,17 @@ imgRequest::OnDataAvailable(nsIRequest*
// Some property objects are not threadsafe, and we need to send
// OnImageAvailable on the main thread, so finish on the main thread.
if (!eventTarget) {
MOZ_ASSERT(NS_IsMainThread());
FinishPreparingForNewPart(result);
} else {
nsCOMPtr<nsIRunnable> runnable =
- new FinishPreparingForNewPartRunnable(this, Move(result));
+ new FinishPreparingForNewPartRunnable(this, std::move(result));
eventTarget->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
}
}
if (!succeeded) {
// Something went wrong; probably a content type issue.
Cancel(NS_IMAGELIB_ERROR_FAILURE);
return NS_BINDING_ABORTED;
--- a/image/imgRequestProxy.cpp
+++ b/image/imgRequestProxy.cpp
@@ -312,33 +312,33 @@ imgRequestProxy::DispatchWithTargetIfAva
{
LOG_FUNC(gImgLog, "imgRequestProxy::DispatchWithTargetIfAvailable");
// This method should only be used when it is *expected* that we are
// dispatching an event (e.g. we want to handle an event asynchronously)
// rather we need to (e.g. we are in the wrong scheduler group context).
// As such, we do not set mHadDispatch for telemetry purposes.
if (mEventTarget) {
- mEventTarget->Dispatch(Move(aEvent), NS_DISPATCH_NORMAL);
+ mEventTarget->Dispatch(std::move(aEvent), NS_DISPATCH_NORMAL);
return NS_OK;
}
- return NS_DispatchToMainThread(Move(aEvent));
+ return NS_DispatchToMainThread(std::move(aEvent));
}
void
imgRequestProxy::DispatchWithTarget(already_AddRefed<nsIRunnable> aEvent)
{
LOG_FUNC(gImgLog, "imgRequestProxy::DispatchWithTarget");
MOZ_ASSERT(mListener || mTabGroup);
MOZ_ASSERT(mEventTarget);
mHadDispatch = true;
- mEventTarget->Dispatch(Move(aEvent), NS_DISPATCH_NORMAL);
+ mEventTarget->Dispatch(std::move(aEvent), NS_DISPATCH_NORMAL);
}
void
imgRequestProxy::AddToOwner(nsIDocument* aLoadingDocument)
{
// An imgRequestProxy can be initialized with neither a listener nor a
// document. The caller could follow up later by cloning the canonical
// imgRequestProxy with the actual listener. This is possible because
@@ -421,17 +421,17 @@ imgRequestProxy::RemoveFromLoadGroup()
LOG_FUNC(gImgLog, "imgRequestProxy::RemoveFromLoadGroup -- dispatch");
/* We take away the load group from the request temporarily; this prevents
additional dispatches via RemoveFromLoadGroup occurring, as well as
MoveToBackgroundInLoadGroup from removing and readding. This is safe
because we know that once we get here, blocking the load group at all is
unnecessary. */
mIsInLoadGroup = false;
- nsCOMPtr<nsILoadGroup> loadGroup = Move(mLoadGroup);
+ nsCOMPtr<nsILoadGroup> loadGroup = std::move(mLoadGroup);
RefPtr<imgRequestProxy> self(this);
DispatchWithTargetIfAvailable(NS_NewRunnableFunction(
"imgRequestProxy::RemoveFromLoadGroup",
[self, loadGroup]() -> void {
loadGroup->RemoveRequest(self, nullptr, NS_OK);
}));
return;
}
--- a/image/imgTools.cpp
+++ b/image/imgTools.cpp
@@ -43,18 +43,18 @@ public:
NS_DECL_ISUPPORTS_INHERITED
ImageDecoderHelper(already_AddRefed<image::Image> aImage,
already_AddRefed<nsIInputStream> aInputStream,
nsIEventTarget* aEventTarget,
imgIContainerCallback* aCallback,
nsIEventTarget* aCallbackEventTarget)
: Runnable("ImageDecoderHelper")
- , mImage(Move(aImage))
- , mInputStream(Move(aInputStream))
+ , mImage(std::move(aImage))
+ , mInputStream(std::move(aInputStream))
, mEventTarget(aEventTarget)
, mCallback(aCallback)
, mCallbackEventTarget(aCallbackEventTarget)
, mStatus(NS_OK)
{
MOZ_ASSERT(NS_IsMainThread());
}
--- a/image/test/gtest/TestADAM7InterpolatingFilter.cpp
+++ b/image/test/gtest/TestADAM7InterpolatingFilter.cpp
@@ -236,17 +236,17 @@ WriteUninterpolatedPixels(SurfaceFilter*
uint8_t aPass,
const vector<BGRAColor>& aColors)
{
WriteState result = WriteState::NEED_MORE_DATA;
for (int32_t row = 0; row < aSize.height; ++row) {
// Compute uninterpolated pixels for this row.
vector<BGRAColor> pixels =
- Move(ADAM7HorizontallyInterpolatedRow(aPass, row, aSize.width,
+ std::move(ADAM7HorizontallyInterpolatedRow(aPass, row, aSize.width,
ShouldInterpolate::eNo, aColors));
// Write them to the surface.
auto pixelIterator = pixels.cbegin();
result = aFilter->WritePixelsToRow<uint32_t>([&]{
return AsVariant((*pixelIterator++).AsPixel());
});
@@ -270,17 +270,17 @@ CheckHorizontallyInterpolatedImage(Decod
for (int32_t row = 0; row < aSize.height; ++row) {
if (!IsImportantRow(row, aPass)) {
continue; // Don't check rows which aren't important on this pass.
}
// Compute the expected pixels, *with* interpolation to match what the
// filter should have done.
vector<BGRAColor> expectedPixels =
- Move(ADAM7HorizontallyInterpolatedRow(aPass, row, aSize.width,
+ std::move(ADAM7HorizontallyInterpolatedRow(aPass, row, aSize.width,
ShouldInterpolate::eYes, aColors));
if (!RowHasPixels(surface, row, expectedPixels)) {
return false;
}
}
return true;
--- a/image/test/gtest/TestAnimationFrameBuffer.cpp
+++ b/image/test/gtest/TestAnimationFrameBuffer.cpp
@@ -23,17 +23,17 @@ CreateEmptyFrame()
}
static bool
Fill(AnimationFrameBuffer& buffer, size_t aLength)
{
bool keepDecoding = false;
for (size_t i = 0; i < aLength; ++i) {
RawAccessFrameRef frame = CreateEmptyFrame();
- keepDecoding = buffer.Insert(Move(frame->RawAccessRef()));
+ keepDecoding = buffer.Insert(std::move(frame->RawAccessRef()));
}
return keepDecoding;
}
static void
CheckFrames(const AnimationFrameBuffer& buffer, size_t aStart, size_t aEnd, bool aExpected)
{
for (size_t i = aStart; i < aEnd; ++i) {
@@ -128,17 +128,17 @@ TEST_F(ImageAnimationFrameBuffer, Finish
buffer.Initialize(kThreshold, kBatch, 0);
const auto& frames = buffer.Frames();
EXPECT_EQ(kBatch * 2, buffer.PendingDecode());
RawAccessFrameRef firstFrame;
for (size_t i = 0; i < 5; ++i) {
RawAccessFrameRef frame = CreateEmptyFrame();
- bool keepDecoding = buffer.Insert(Move(frame->RawAccessRef()));
+ bool keepDecoding = buffer.Insert(std::move(frame->RawAccessRef()));
EXPECT_TRUE(keepDecoding);
EXPECT_FALSE(buffer.SizeKnown());
if (i == 4) {
EXPECT_EQ(size_t(15), buffer.PendingDecode());
keepDecoding = buffer.MarkComplete();
EXPECT_FALSE(keepDecoding);
EXPECT_TRUE(buffer.SizeKnown());
@@ -149,17 +149,17 @@ TEST_F(ImageAnimationFrameBuffer, Finish
EXPECT_FALSE(buffer.MayDiscard());
imgFrame* gotFrame = buffer.Get(i);
EXPECT_EQ(frame.get(), gotFrame);
ASSERT_EQ(i + 1, frames.Length());
EXPECT_EQ(frame.get(), frames[i].get());
if (i == 0) {
- firstFrame = Move(frame);
+ firstFrame = std::move(frame);
EXPECT_EQ(size_t(0), buffer.Displayed());
} else {
EXPECT_EQ(i - 1, buffer.Displayed());
bool restartDecoder = buffer.AdvanceTo(i);
EXPECT_FALSE(restartDecoder);
EXPECT_EQ(i, buffer.Displayed());
}
--- a/image/test/gtest/TestSourceBuffer.cpp
+++ b/image/test/gtest/TestSourceBuffer.cpp
@@ -608,30 +608,30 @@ TEST_F(ImageSourceBuffer, SourceBufferIt
auto GetIterator = [&]{
SourceBufferIterator lambdaIterator = mSourceBuffer->Iterator();
CheckedAdvanceIterator(lambdaIterator, chunkLength);
return lambdaIterator;
};
// Move-construct |movedIterator| from the iterator returned from
// GetIterator() and check that its state is as we expect.
- SourceBufferIterator movedIterator = Move(GetIterator());
+ SourceBufferIterator movedIterator = std::move(GetIterator());
EXPECT_TRUE(movedIterator.Data());
EXPECT_EQ(chunkLength, movedIterator.Length());
ExpectChunkAndByteCount(movedIterator, 1, chunkLength);
// Make sure that we can advance the iterator.
CheckedAdvanceIterator(movedIterator, chunkLength, 2, totalLength);
// Make sure that the iterator handles completion properly.
CheckIteratorIsComplete(movedIterator, 2, totalLength);
// Move-assign |movedIterator| from the iterator returned from
// GetIterator() and check that its state is as we expect.
- movedIterator = Move(GetIterator());
+ movedIterator = std::move(GetIterator());
EXPECT_TRUE(movedIterator.Data());
EXPECT_EQ(chunkLength, movedIterator.Length());
ExpectChunkAndByteCount(movedIterator, 1, chunkLength);
// Make sure that we can advance the iterator.
CheckedAdvanceIterator(movedIterator, chunkLength, 2, totalLength);
// Make sure that the iterator handles completion properly.
--- a/image/test/gtest/TestSurfacePipeIntegration.cpp
+++ b/image/test/gtest/TestSurfacePipeIntegration.cpp
@@ -21,23 +21,23 @@ namespace mozilla {
namespace image {
class TestSurfacePipeFactory
{
public:
static SurfacePipe SimpleSurfacePipe()
{
SurfacePipe pipe;
- return Move(pipe);
+ return std::move(pipe);
}
template <typename T>
static SurfacePipe SurfacePipeFromPipeline(T&& aPipeline)
{
- return SurfacePipe { Move(aPipeline) };
+ return SurfacePipe { std::move(aPipeline) };
}
private:
TestSurfacePipeFactory() { }
};
} // namespace image
} // namespace mozilla
--- a/intl/locale/LocaleService.cpp
+++ b/intl/locale/LocaleService.cpp
@@ -330,17 +330,17 @@ void
LocaleService::RequestedLocalesChanged()
{
MOZ_ASSERT(mIsServer, "This should only be called in the server mode.");
nsTArray<nsCString> newLocales;
ReadRequestedLocales(newLocales);
if (mRequestedLocales != newLocales) {
- mRequestedLocales = Move(newLocales);
+ mRequestedLocales = std::move(newLocales);
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->NotifyObservers(nullptr, "intl:requested-locales-changed", nullptr);
}
LocalesChanged();
}
}
@@ -353,17 +353,17 @@ LocaleService::LocalesChanged()
if (mAppLocales.IsEmpty()) {
return;
}
nsTArray<nsCString> newLocales;
NegotiateAppLocales(newLocales);
if (mAppLocales != newLocales) {
- mAppLocales = Move(newLocales);
+ mAppLocales = std::move(newLocales);
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->NotifyObservers(nullptr, "intl:app-locales-changed", nullptr);
}
}
}
// After trying each step of the negotiation algorithm for each requested locale,
@@ -956,17 +956,17 @@ LocaleService::SetAvailableLocales(const
if (!SanitizeForBCP47(locale, true)) {
NS_ERROR("Invalid language tag provided to SetAvailableLocales!");
return NS_ERROR_INVALID_ARG;
}
newLocales.AppendElement(locale);
}
if (newLocales != mAvailableLocales) {
- mAvailableLocales = Move(newLocales);
+ mAvailableLocales = std::move(newLocales);
LocalesChanged();
}
return NS_OK;
}
NS_IMETHODIMP
LocaleService::GetPackagedLocales(uint32_t* aCount, char*** aOutArray)
--- a/intl/locale/OSPreferences.cpp
+++ b/intl/locale/OSPreferences.cpp
@@ -71,17 +71,17 @@ OSPreferences::GetRegionalPrefsLocales(n
void
OSPreferences::Refresh()
{
nsTArray<nsCString> newLocales;
ReadSystemLocales(newLocales);
if (mSystemLocales != newLocales) {
- mSystemLocales = Move(newLocales);
+ mSystemLocales = std::move(newLocales);
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->NotifyObservers(nullptr, "intl:system-locales-changed", nullptr);
}
}
}
/**
--- a/ipc/chromium/src/base/file_descriptor_shuffle.h
+++ b/ipc/chromium/src/base/file_descriptor_shuffle.h
@@ -33,26 +33,26 @@ namespace base {
// multimapping in place.
class InjectionDelegate {
public:
// Duplicate |fd|, an element of the domain, and write a fresh element of the
// domain into |result|. Returns true iff successful.
virtual bool Duplicate(int* result, int fd) = 0;
// Destructively move |src| to |dest|, overwriting |dest|. Returns true iff
// successful.
- virtual bool Move(int src, int dest) = 0;
+ virtual bool std::move(int src, int dest) = 0;
// Delete an element of the domain.
virtual void Close(int fd) = 0;
};
// An implementation of the InjectionDelegate interface using the file
// descriptor table of the current process as the domain.
class FileDescriptorTableInjection : public InjectionDelegate {
virtual bool Duplicate(int* result, int fd) override;
- virtual bool Move(int src, int dest) override;
+ virtual bool std::move(int src, int dest) override;
virtual void Close(int fd) override;
};
// A single arc of the directed graph which describes an injective multimapping.
struct InjectionArc {
InjectionArc(int in_source, int in_dest, bool in_close)
: source(in_source),
dest(in_dest),
--- a/ipc/chromium/src/base/logging.cc
+++ b/ipc/chromium/src/base/logging.cc
@@ -48,17 +48,17 @@ Logger::~Logger()
NS_DebugBreak(xpcomlevel, mMsg.get(), NULL, mFile, mLine);
}
void
Logger::printf(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
- mMsg = mozilla::VsmprintfAppend(mozilla::Move(mMsg), fmt, args);
+ mMsg = mozilla::VsmprintfAppend(std::move(mMsg), fmt, args);
va_end(args);
}
LazyLogModule Logger::gChromiumPRLog("chromium");
mozilla::Logger&
operator<<(mozilla::Logger& log, const char* s)
{
--- a/ipc/chromium/src/base/message_loop.cc
+++ b/ipc/chromium/src/base/message_loop.cc
@@ -140,29 +140,29 @@ MessageLoop::EventTarget::Dispatch(alrea
if (!mLoop) {
return NS_ERROR_NOT_INITIALIZED;
}
if (aFlags != NS_DISPATCH_NORMAL) {
return NS_ERROR_NOT_IMPLEMENTED;
}
- mLoop->PostTask(Move(aEvent));
+ mLoop->PostTask(std::move(aEvent));
return NS_OK;
}
NS_IMETHODIMP
MessageLoop::EventTarget::DelayedDispatch(already_AddRefed<nsIRunnable> aEvent,
uint32_t aDelayMs)
{
if (!mLoop) {
return NS_ERROR_NOT_INITIALIZED;
}
- mLoop->PostDelayedTask(Move(aEvent), aDelayMs);
+ mLoop->PostDelayedTask(std::move(aEvent), aDelayMs);
return NS_OK;
}
//------------------------------------------------------------------------------
// static
MessageLoop* MessageLoop::current() {
return get_tls_ptr().Get();
@@ -350,73 +350,73 @@ void MessageLoop::Quit() {
if (state_) {
state_->quit_received = true;
} else {
NOTREACHED() << "Must be inside Run to call Quit";
}
}
void MessageLoop::PostTask(already_AddRefed<nsIRunnable> task) {
- PostTask_Helper(Move(task), 0);
+ PostTask_Helper(std::move(task), 0);
}
void MessageLoop::PostDelayedTask(already_AddRefed<nsIRunnable> task, int delay_ms) {
- PostTask_Helper(Move(task), delay_ms);
+ PostTask_Helper(std::move(task), delay_ms);
}
void MessageLoop::PostIdleTask(already_AddRefed<nsIRunnable> task) {
DCHECK(current() == this);
MOZ_ASSERT(NS_IsMainThread());
- PendingTask pending_task(Move(task), false);
- deferred_non_nestable_work_queue_.push(Move(pending_task));
+ PendingTask pending_task(std::move(task), false);
+ deferred_non_nestable_work_queue_.push(std::move(pending_task));
}
// Possibly called on a background thread!
void MessageLoop::PostTask_Helper(already_AddRefed<nsIRunnable> task, int delay_ms) {
if (nsIEventTarget* target = pump_->GetXPCOMThread()) {
nsresult rv;
if (delay_ms) {
- rv = target->DelayedDispatch(Move(task), delay_ms);
+ rv = target->DelayedDispatch(std::move(task), delay_ms);
} else {
- rv = target->Dispatch(Move(task), 0);
+ rv = target->Dispatch(std::move(task), 0);
}
MOZ_ALWAYS_SUCCEEDS(rv);
return;
}
// Tasks should only be queued before or during the Run loop, not after.
MOZ_ASSERT(!shutting_down_);
#ifdef MOZ_TASK_TRACER
nsCOMPtr<nsIRunnable> tracedTask = task;
if (mozilla::tasktracer::IsStartLogging()) {
tracedTask = mozilla::tasktracer::CreateTracedRunnable(tracedTask.forget());
(static_cast<mozilla::tasktracer::TracedRunnable*>(tracedTask.get()))->DispatchTask();
}
PendingTask pending_task(tracedTask.forget(), true);
#else
- PendingTask pending_task(Move(task), true);
+ PendingTask pending_task(std::move(task), true);
#endif
if (delay_ms > 0) {
pending_task.delayed_run_time =
TimeTicks::Now() + TimeDelta::FromMilliseconds(delay_ms);
} else {
DCHECK(delay_ms == 0) << "delay should not be negative";
}
// Warning: Don't try to short-circuit, and handle this thread's tasks more
// directly, as it could starve handling of foreign threads. Put every task
// into this queue.
RefPtr<base::MessagePump> pump;
{
AutoLock locked(incoming_queue_lock_);
- incoming_queue_.push(Move(pending_task));
+ incoming_queue_.push(std::move(pending_task));
pump = pump_;
}
// Since the incoming_queue_ may contain a task that destroys this message
// loop, we cannot exit incoming_queue_lock_ until we are done with |this|.
// We use a stack-based reference to the message pump so that we can call
// ScheduleWork outside of incoming_queue_lock_.
pump->ScheduleWork();
@@ -460,28 +460,28 @@ bool MessageLoop::DeferOrRunPendingTask(
RunTask(pending_task.task.forget());
// Show that we ran a task (Note: a new one might arrive as a
// consequence!).
return true;
}
// We couldn't run the task now because we're in a nested message loop
// and the task isn't nestable.
- deferred_non_nestable_work_queue_.push(Move(pending_task));
+ deferred_non_nestable_work_queue_.push(std::move(pending_task));
return false;
}
void MessageLoop::AddToDelayedWorkQueue(const PendingTask& pending_task) {
// Move to the delayed work queue. Initialize the sequence number
// before inserting into the delayed_work_queue_. The sequence number
// is used to faciliate FIFO sorting when two tasks have the same
// delayed_run_time value.
PendingTask new_pending_task(pending_task);
new_pending_task.sequence_num = next_sequence_num_++;
- delayed_work_queue_.push(Move(new_pending_task));
+ delayed_work_queue_.push(std::move(new_pending_task));
}
void MessageLoop::ReloadWorkQueue() {
// We can improve performance of our loading tasks from incoming_queue_ to
// work_queue_ by waiting until the last minute (work_queue_ is empty) to
// load. That reduces the number of locks-per-task significantly when our
// queues get large.
if (!work_queue_.empty())
@@ -518,26 +518,26 @@ bool MessageLoop::DoWork() {
for (;;) {
ReloadWorkQueue();
if (work_queue_.empty())
break;
// Execute oldest task.
do {
- PendingTask pending_task = Move(work_queue_.front());
+ PendingTask pending_task = std::move(work_queue_.front());
work_queue_.pop();
if (!pending_task.delayed_run_time.is_null()) {
// NB: Don't move, because we use this later!
AddToDelayedWorkQueue(pending_task);
// If we changed the topmost task, then it is time to re-schedule.
if (delayed_work_queue_.top().task == pending_task.task)
pump_->ScheduleDelayedWork(pending_task.delayed_run_time);
} else {
- if (DeferOrRunPendingTask(Move(pending_task)))
+ if (DeferOrRunPendingTask(std::move(pending_task)))
return true;
}
} while (!work_queue_.empty());
}
// Nothing happened.
return false;
}
@@ -554,17 +554,17 @@ bool MessageLoop::DoDelayedWork(TimeTick
}
PendingTask pending_task = delayed_work_queue_.top();
delayed_work_queue_.pop();
if (!delayed_work_queue_.empty())
*next_delayed_work_time = delayed_work_queue_.top().delayed_run_time;
- return DeferOrRunPendingTask(Move(pending_task));
+ return DeferOrRunPendingTask(std::move(pending_task));
}
bool MessageLoop::DoIdleWork() {
if (ProcessNextDelayedNonNestableTask())
return true;
if (state_->quit_received)
pump_->Quit();
--- a/ipc/chromium/src/base/pickle.cc
+++ b/ipc/chromium/src/base/pickle.cc
@@ -150,29 +150,29 @@ Pickle::Pickle(uint32_t header_size, con
DCHECK(header_size <= kHeaderSegmentCapacity);
MOZ_RELEASE_ASSERT(header_size <= length);
header_ = reinterpret_cast<Header*>(buffers_.Start());
memcpy(header_, data, length);
}
Pickle::Pickle(Pickle&& other)
- : buffers_(mozilla::Move(other.buffers_)),
+ : buffers_(std::move(other.buffers_)),
header_(other.header_),
header_size_(other.header_size_) {
other.header_ = nullptr;
}
Pickle::~Pickle() {
}
Pickle& Pickle::operator=(Pickle&& other) {
- BufferList tmp = mozilla::Move(other.buffers_);
- other.buffers_ = mozilla::Move(buffers_);
- buffers_ = mozilla::Move(tmp);
+ BufferList tmp = std::move(other.buffers_);
+ other.buffers_ = std::move(buffers_);
+ buffers_ = std::move(tmp);
//std::swap(buffers_, other.buffers_);
std::swap(header_, other.header_);
std::swap(header_size_, other.header_size_);
return *this;
}
bool Pickle::ReadBool(PickleIterator* iter, bool* result) const {
--- a/ipc/chromium/src/base/task.h
+++ b/ipc/chromium/src/base/task.h
@@ -22,25 +22,25 @@ namespace details {
// Call the given method on the given object. Arguments are passed by move
// semantics from the given tuple. If the tuple has length N, the sequence must
// be IndexSequence<0, 1, ..., N-1>.
template<size_t... Indices, class ObjT, class Method, typename... Args>
void CallMethod(std::index_sequence<Indices...>, ObjT* obj, Method method,
mozilla::Tuple<Args...>& arg)
{
- (obj->*method)(mozilla::Move(mozilla::Get<Indices>(arg))...);
+ (obj->*method)(std::move(mozilla::Get<Indices>(arg))...);
}
// Same as above, but call a function.
template<size_t... Indices, typename Function, typename... Args>
void CallFunction(std::index_sequence<Indices...>, Function function,
mozilla::Tuple<Args...>& arg)
{
- (*function)(mozilla::Move(mozilla::Get<Indices>(arg))...);
+ (*function)(std::move(mozilla::Get<Indices>(arg))...);
}
} // namespace details
// Call a method on the given object. Arguments are passed by move semantics
// from the given tuple.
template<class ObjT, class Method, typename... Args>
void DispatchTupleToMethod(ObjT* obj, Method method, mozilla::Tuple<Args...>& arg)
--- a/ipc/chromium/src/chrome/common/child_process_host.cc
+++ b/ipc/chromium/src/chrome/common/child_process_host.cc
@@ -56,17 +56,17 @@ bool ChildProcessHost::CreateChannel(Fil
}
ChildProcessHost::ListenerHook::ListenerHook(ChildProcessHost* host)
: host_(host) {
}
void ChildProcessHost::ListenerHook::OnMessageReceived(
IPC::Message&& msg) {
- host_->OnMessageReceived(mozilla::Move(msg));
+ host_->OnMessageReceived(std::move(msg));
}
void ChildProcessHost::ListenerHook::OnChannelConnected(int32_t peer_pid) {
host_->opening_channel_ = false;
host_->OnChannelConnected(peer_pid);
}
void ChildProcessHost::ListenerHook::OnChannelError() {
--- a/ipc/chromium/src/chrome/common/ipc_channel_posix.cc
+++ b/ipc/chromium/src/chrome/common/ipc_channel_posix.cc
@@ -568,17 +568,17 @@ bool Channel::ChannelImpl::ProcessIncomi
listener_->OnChannelConnected(MessageIterator(m).NextInt());
#if defined(OS_MACOSX)
} else if (m.routing_id() == MSG_ROUTING_NONE &&
m.type() == RECEIVED_FDS_MESSAGE_TYPE) {
DCHECK(m.fd_cookie() != 0);
CloseDescriptors(m.fd_cookie());
#endif
} else {
- listener_->OnMessageReceived(mozilla::Move(m));
+ listener_->OnMessageReceived(std::move(m));
}
incoming_message_.reset();
}
input_overflow_fds_ = std::vector<int>(&fds[fds_i], &fds[num_fds]);
// When the input data buffer is empty, the overflow fds should be too. If
--- a/ipc/chromium/src/chrome/common/ipc_channel_win.cc
+++ b/ipc/chromium/src/chrome/common/ipc_channel_win.cc
@@ -432,17 +432,17 @@ bool Channel::ChannelImpl::ProcessIncomi
// Something went wrong. Abort connection.
Close();
listener_->OnChannelError();
return false;
}
waiting_for_shared_secret_ = false;
listener_->OnChannelConnected(claimed_pid);
} else {
- listener_->OnMessageReceived(mozilla::Move(m));
+ listener_->OnMessageReceived(std::move(m));
}
incoming_message_.reset();
}
bytes_read = 0; // Get more data.
}
--- a/ipc/chromium/src/chrome/common/ipc_message.cc
+++ b/ipc/chromium/src/chrome/common/ipc_message.cc
@@ -95,17 +95,17 @@ Message::Message(int32_t routing_id,
#endif
Message::Message(const char* data, int data_len)
: Pickle(MSG_HEADER_SZ_DATA, data, data_len)
{
MOZ_COUNT_CTOR(IPC::Message);
}
-Message::Message(Message&& other) : Pickle(mozilla::Move(other)) {
+Message::Message(Message&& other) : Pickle(std::move(other)) {
MOZ_COUNT_CTOR(IPC::Message);
#if defined(OS_POSIX)
file_descriptor_set_ = other.file_descriptor_set_.forget();
#endif
}
/*static*/ Message*
Message::IPDLMessage(int32_t routing_id,
@@ -133,17 +133,17 @@ Message::ForInterruptDispatchError()
auto& flags = m->header()->flags;
flags.SetInterrupt();
flags.SetReply();
flags.SetReplyError();
return m;
}
Message& Message::operator=(Message&& other) {
- *static_cast<Pickle*>(this) = mozilla::Move(other);
+ *static_cast<Pickle*>(this) = std::move(other);
#if defined(OS_POSIX)
file_descriptor_set_.swap(other.file_descriptor_set_);
#endif
return *this;
}
#if defined(OS_POSIX)
--- a/ipc/glue/BackgroundImpl.cpp
+++ b/ipc/glue/BackgroundImpl.cpp
@@ -526,17 +526,17 @@ class ParentImpl::ConnectActorRunnable f
nsTArray<ParentImpl*>* mLiveActorArray;
public:
ConnectActorRunnable(ParentImpl* aActor,
Endpoint<PBackgroundParent>&& aEndpoint,
nsTArray<ParentImpl*>* aLiveActorArray)
: Runnable("Background::ParentImpl::ConnectActorRunnable")
, mActor(aActor)
- , mEndpoint(Move(aEndpoint))
+ , mEndpoint(std::move(aEndpoint))
, mLiveActorArray(aLiveActorArray)
{
AssertIsInMainProcess();
AssertIsOnMainThread();
MOZ_ASSERT(mEndpoint.IsValid());
MOZ_ASSERT(aLiveActorArray);
}
@@ -688,17 +688,17 @@ BackgroundParent::GetLiveActorArray(
return ParentImpl::GetLiveActorArray(aBackgroundActor, aLiveActorArray);
}
// static
bool
BackgroundParent::Alloc(ContentParent* aContent,
Endpoint<PBackgroundParent>&& aEndpoint)
{
- return ParentImpl::Alloc(aContent, Move(aEndpoint));
+ return ParentImpl::Alloc(aContent, std::move(aEndpoint));
}
// -----------------------------------------------------------------------------
// BackgroundChild Public Methods
// -----------------------------------------------------------------------------
// static
void
@@ -891,17 +891,17 @@ ParentImpl::Alloc(ContentParent* aConten
MOZ_ASSERT(sLiveActorsForBackgroundThread);
sLiveActorCount++;
RefPtr<ParentImpl> actor = new ParentImpl(aContent);
nsCOMPtr<nsIRunnable> connectRunnable =
- new ConnectActorRunnable(actor, Move(aEndpoint),
+ new ConnectActorRunnable(actor, std::move(aEndpoint),
sLiveActorsForBackgroundThread);
if (NS_FAILED(sBackgroundThread->Dispatch(connectRunnable,
NS_DISPATCH_NORMAL))) {
NS_WARNING("Failed to dispatch connect runnable!");
MOZ_ASSERT(sLiveActorCount);
sLiveActorCount--;
@@ -1283,17 +1283,17 @@ ParentImpl::ConnectActorRunnable::Run()
AssertIsInMainProcess();
AssertIsOnBackgroundThread();
// Transfer ownership to this thread. If Open() fails then we will release
// this reference in Destroy.
ParentImpl* actor;
mActor.forget(&actor);
- Endpoint<PBackgroundParent> endpoint = Move(mEndpoint);
+ Endpoint<PBackgroundParent> endpoint = std::move(mEndpoint);
if (!endpoint.Bind(actor)) {
actor->Destroy();
return NS_ERROR_FAILURE;
}
actor->SetLiveActorArray(mLiveActorArray);
@@ -1311,18 +1311,18 @@ CreateActorHelper::BlockAndGetResults(Re
while (mWaiting) {
lock.Wait();
}
if (NS_WARN_IF(NS_FAILED(mMainThreadResultCode))) {
return mMainThreadResultCode;
}
- aParentActor = Move(mParentActor);
- aThread = Move(mThread);
+ aParentActor = std::move(mParentActor);
+ aThread = std::move(mThread);
return NS_OK;
}
nsresult
ParentImpl::
CreateActorHelper::RunOnMainThread()
{
AssertIsOnMainThread();
@@ -1518,27 +1518,27 @@ ChildImpl::GetOrCreateForCurrentThread()
CRASH_IN_CHILD_PROCESS("Failed to bind ChildImpl!");
return nullptr;
}
strongActor->SetActorAlive();
if (NS_IsMainThread()) {
- if (!content->SendInitBackground(Move(parent))) {
+ if (!content->SendInitBackground(std::move(parent))) {
MOZ_CRASH("Failed to create top level actor!");
return nullptr;
}
} else {
nsCOMPtr<nsIRunnable> runnable =
NewRunnableMethod<Endpoint<PBackgroundParent>&&>(
"dom::ContentChild::SendInitBackground",
content,
&ContentChild::SendInitBackground,
- Move(parent));
+ std::move(parent));
MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
}
RefPtr<ChildImpl>& actor = threadLocalInfo->mActor;
strongActor.swap(actor);
return actor;
}
--- a/ipc/glue/BackgroundUtils.cpp
+++ b/ipc/glue/BackgroundUtils.cpp
@@ -203,17 +203,17 @@ PrincipalToPrincipalInfo(nsIPrincipal* a
return rv;
}
// append that spec to the whitelist
whitelistInfo.AppendElement(info);
}
*aPrincipalInfo =
ExpandedPrincipalInfo(aPrincipal->OriginAttributesRef(),
- Move(whitelistInfo));
+ std::move(whitelistInfo));
return NS_OK;
}
// must be a content principal
nsCOMPtr<nsIURI> uri;
rv = aPrincipal->GetURI(getter_AddRefs(uri));
if (NS_WARN_IF(NS_FAILED(rv))) {
@@ -567,17 +567,17 @@ LoadInfoArgsToLoadInfo(const OptionalLoa
loadInfoArgs.frameOuterWindowID(),
loadInfoArgs.enforceSecurity(),
loadInfoArgs.initialSecurityCheckDone(),
loadInfoArgs.isInThirdPartyContext(),
loadInfoArgs.isDocshellReload(),
loadInfoArgs.originAttributes(),
redirectChainIncludingInternalRedirects,
redirectChain,
- Move(ancestorPrincipals),
+ std::move(ancestorPrincipals),
loadInfoArgs.ancestorOuterWindowIDs(),
loadInfoArgs.corsUnsafeHeaders(),
loadInfoArgs.forcePreflight(),
loadInfoArgs.isPreflight(),
loadInfoArgs.loadTriggeredFromExternal(),
loadInfoArgs.serviceWorkerTaintingSynthesized()
);
--- a/ipc/glue/CrashReporterHost.cpp
+++ b/ipc/glue/CrashReporterHost.cpp
@@ -163,17 +163,17 @@ CrashReporterHost::GenerateMinidumpAndPa
#else
childHandle = aChildProcess->GetChildProcessHandle();
#endif
if (!mCreateMinidumpCallback.IsEmpty()) {
aCallback(false);
return;
}
- mCreateMinidumpCallback.Init(Move(aCallback), aAsync);
+ mCreateMinidumpCallback.Init(std::move(aCallback), aAsync);
if (!childHandle) {
NS_WARNING("Failed to get child process handle.");
mCreateMinidumpCallback.Invoke(false);
return;
}
nsCOMPtr<nsIAsyncShutdownBlocker> shutdownBlocker;
@@ -209,17 +209,17 @@ CrashReporterHost::GenerateMinidumpAndPa
}
};
CrashReporter::CreateMinidumpsAndPair(childHandle,
mThreadId,
aPairName,
aMinidumpToPair,
getter_AddRefs(mTargetDump),
- Move(callback),
+ std::move(callback),
aAsync);
}
/* static */ void
CrashReporterHost::NotifyCrashService(GeckoProcessType aProcessType,
const nsString& aChildDumpID,
const AnnotationTable* aNotes)
{
--- a/ipc/glue/CrashReporterHost.h
+++ b/ipc/glue/CrashReporterHost.h
@@ -33,17 +33,17 @@ class CrashReporterHost
public:
template <typename T>
class CallbackWrapper {
public:
void Init(std::function<void(T)>&& aCallback, bool aAsync)
{
- mCallback = Move(aCallback);
+ mCallback = std::move(aCallback);
mAsync = aAsync;
if (IsAsync()) {
// Don't call do_GetCurrentThread() if this is called synchronously
// because 1. it's unnecessary, and 2. more importantly, it might create
// one if called from a native thread, and the thread will be leaked.
mTargetThread = do_GetCurrentThread();
}
}
@@ -56,17 +56,17 @@ public:
bool IsAsync()
{
return mAsync;
}
void Invoke(T aResult)
{
if (IsAsync()) {
- decltype(mCallback) callback = Move(mCallback);
+ decltype(mCallback) callback = std::move(mCallback);
mTargetThread->
Dispatch(NS_NewRunnableFunction("ipc::CrashReporterHost::CallbackWrapper::Invoke",
[callback, aResult](){
callback(aResult);
}), NS_DISPATCH_NORMAL);
} else {
MOZ_ASSERT(!mTargetThread);
mCallback(aResult);
--- a/ipc/glue/FileDescriptor.cpp
+++ b/ipc/glue/FileDescriptor.cpp
@@ -41,17 +41,17 @@ FileDescriptor::FileDescriptor(const Fil
: mHandle(INVALID_HANDLE)
{
Assign(aOther);
}
FileDescriptor::FileDescriptor(FileDescriptor&& aOther)
: mHandle(INVALID_HANDLE)
{
- *this = mozilla::Move(aOther);
+ *this = std::move(aOther);
}
FileDescriptor::FileDescriptor(PlatformHandleType aHandle)
: mHandle(INVALID_HANDLE)
{
mHandle = Clone(aHandle);
}
--- a/ipc/glue/GeckoChildProcessHost.cpp
+++ b/ipc/glue/GeckoChildProcessHost.cpp
@@ -1157,17 +1157,17 @@ GeckoChildProcessHost::OnChannelConnecte
lock.Notify();
}
void
GeckoChildProcessHost::OnMessageReceived(IPC::Message&& aMsg)
{
// We never process messages ourself, just save them up for the next
// listener.
- mQueue.push(Move(aMsg));
+ mQueue.push(std::move(aMsg));
}
void
GeckoChildProcessHost::OnChannelError()
{
// Update the process state to an error state if we have a channel
// error before we're connected. This fixes certain failures,
// but does not address the full range of possible issues described
--- a/ipc/glue/IPCMessageUtils.h
+++ b/ipc/glue/IPCMessageUtils.h
@@ -877,17 +877,17 @@ struct ParamTraits<JSStructuredCloneData
bool success;
mozilla::BufferList<js::SystemAllocPolicy> out =
buffers.MoveFallible<js::SystemAllocPolicy>(&success);
if (!success) {
return false;
}
- *aResult = JSStructuredCloneData(Move(out), JS::StructuredCloneScope::DifferentProcess);
+ *aResult = JSStructuredCloneData(std::move(out), JS::StructuredCloneScope::DifferentProcess);
return true;
}
};
template <>
struct ParamTraits<mozilla::SerializedStructuredCloneBuffer>
{
@@ -937,17 +937,17 @@ struct ParamTraits<mozilla::Maybe<T>>
if (!ReadParam(msg, iter, &isSome)) {
return false;
}
if (isSome) {
T tmp;
if (!ReadParam(msg, iter, &tmp)) {
return false;
}
- *result = mozilla::Some(mozilla::Move(tmp));
+ *result = mozilla::Some(std::move(tmp));
} else {
*result = mozilla::Nothing();
}
return true;
}
};
template<typename T>
--- a/ipc/glue/MessageChannel.cpp
+++ b/ipc/glue/MessageChannel.cpp
@@ -187,17 +187,17 @@ public:
{
MOZ_RELEASE_ASSERT(mMessageName || mMoved);
}
InterruptFrame& operator=(InterruptFrame&& aOther)
{
MOZ_RELEASE_ASSERT(&aOther != this);
this->~InterruptFrame();
- new (this) InterruptFrame(Move(aOther));
+ new (this) InterruptFrame(std::move(aOther));
return *this;
}
bool IsInterruptIncall() const
{
return INTR_SEMS == mMesageSemantics && IN_MESSAGE == mDirection;
}
@@ -413,27 +413,27 @@ public:
return mTransaction;
}
void ReceivedReply(IPC::Message&& aMessage) {
MOZ_RELEASE_ASSERT(aMessage.seqno() == mSeqno);
MOZ_RELEASE_ASSERT(aMessage.transaction_id() == mTransaction);
MOZ_RELEASE_ASSERT(!mReply);
IPC_LOG("Reply received on worker thread: seqno=%d", mSeqno);
- mReply = MakeUnique<IPC::Message>(Move(aMessage));
+ mReply = MakeUnique<IPC::Message>(std::move(aMessage));
MOZ_RELEASE_ASSERT(IsComplete());
}
void HandleReply(IPC::Message&& aMessage) {
AutoEnterTransaction *cur = mChan->mTransactionStack;
MOZ_RELEASE_ASSERT(cur == this);
while (cur) {
MOZ_RELEASE_ASSERT(cur->mActive);
if (aMessage.seqno() == cur->mSeqno) {
- cur->ReceivedReply(Move(aMessage));
+ cur->ReceivedReply(std::move(aMessage));
break;
}
cur = cur->mNext;
MOZ_RELEASE_ASSERT(cur);
}
}
bool IsComplete() {
@@ -453,17 +453,17 @@ public:
}
bool IsError() {
MOZ_RELEASE_ASSERT(mReply);
return mReply->is_reply_error();
}
UniquePtr<IPC::Message> GetReply() {
- return Move(mReply);
+ return std::move(mReply);
}
private:
MessageChannel *mChan;
// Active is true if this transaction is on the mChan->mTransactionStack
// stack. Generally we're not on the stack if the transaction was canceled
// or if it was for a message that doesn't require transactions (an async
@@ -933,17 +933,17 @@ MessageChannel::Send(Message* aMsg)
return true;
}
void
MessageChannel::SendMessageToLink(Message* aMsg)
{
if (mIsPostponingSends) {
UniquePtr<Message> msg(aMsg);
- mPostponedSends.push_back(Move(msg));
+ mPostponedSends.push_back(std::move(msg));
return;
}
mLink->SendMessage(aMsg);
}
void
MessageChannel::BeginPostponingSends()
{
@@ -975,17 +975,17 @@ MessageChannel::StopPostponingSends()
mPostponedSends.clear();
}
UniquePtr<MessageChannel::UntypedCallbackHolder>
MessageChannel::PopCallback(const Message& aMsg)
{
auto iter = mPendingResponses.find(aMsg.seqno());
if (iter != mPendingResponses.end()) {
- UniquePtr<MessageChannel::UntypedCallbackHolder> ret = Move(iter->second);
+ UniquePtr<MessageChannel::UntypedCallbackHolder> ret = std::move(iter->second);
mPendingResponses.erase(iter);
gUnresolvedResponses--;
return ret;
}
return nullptr;
}
void
@@ -1177,17 +1177,17 @@ MessageChannel::OnMessageReceivedFromLin
IPC_LOG("Received reply to timedout message; igoring; xid=%d", mTimedOutMessageSeqno);
EndTimeout();
return;
}
MOZ_RELEASE_ASSERT(AwaitingSyncReply());
MOZ_RELEASE_ASSERT(!mTimedOutMessageSeqno);
- mTransactionStack->HandleReply(Move(aMsg));
+ mTransactionStack->HandleReply(std::move(aMsg));
NotifyWorkerThread();
return;
}
// Nested messages cannot be compressed.
MOZ_RELEASE_ASSERT(aMsg.compress_type() == IPC::Message::COMPRESSION_NONE ||
aMsg.nested_level() == IPC::Message::NOT_NESTED);
@@ -1197,17 +1197,17 @@ MessageChannel::OnMessageReceivedFromLin
mPending.getLast()->Msg().type() == aMsg.type() &&
mPending.getLast()->Msg().routing_id() == aMsg.routing_id());
if (compress) {
// This message type has compression enabled, and the back of the
// queue was the same message type and routed to the same destination.
// Replace it with the newer message.
MOZ_RELEASE_ASSERT(mPending.getLast()->Msg().compress_type() ==
IPC::Message::COMPRESSION_ENABLED);
- mPending.getLast()->Msg() = Move(aMsg);
+ mPending.getLast()->Msg() = std::move(aMsg);
reuseTask = true;
}
} else if (aMsg.compress_type() == IPC::Message::COMPRESSION_ALL && !mPending.isEmpty()) {
for (MessageTask* p = mPending.getLast(); p; p = p->getPrevious()) {
if (p->Msg().type() == aMsg.type() &&
p->Msg().routing_id() == aMsg.routing_id())
{
@@ -1264,17 +1264,17 @@ MessageChannel::OnMessageReceivedFromLin
//
// Note that, we may notify the main thread even though the monitor is not
// blocked. This is okay, since we always check for pending events before
// blocking again.
#ifdef MOZ_TASK_TRACER
aMsg.TaskTracerDispatch();
#endif
- RefPtr<MessageTask> task = new MessageTask(this, Move(aMsg));
+ RefPtr<MessageTask> task = new MessageTask(this, std::move(aMsg));
mPending.insertBack(task);
if (!alwaysDeferred) {
mMaybeDeferredPendingCount++;
}
if (shouldWakeUp) {
NotifyWorkerThread();
@@ -1335,17 +1335,17 @@ MessageChannel::ProcessPendingRequests(A
// Only log the interesting messages.
if (msg.is_sync() || msg.nested_level() == IPC::Message::NESTED_INSIDE_CPOW) {
IPC_LOG("ShouldDeferMessage(seqno=%d) = %d", msg.seqno(), defer);
}
if (!defer) {
MOZ_ASSERT(!IsAlwaysDeferred(msg));
- if (!toProcess.append(Move(msg)))
+ if (!toProcess.append(std::move(msg)))
MOZ_CRASH();
mMaybeDeferredPendingCount--;
p = p->removeAndGetNext();
continue;
}
p = p->getNext();
@@ -1354,17 +1354,17 @@ MessageChannel::ProcessPendingRequests(A
if (toProcess.empty()) {
break;
}
// Processing these messages could result in more messages, so we
// loop around to check for more afterwards.
for (auto it = toProcess.begin(); it != toProcess.end(); it++) {
- ProcessPendingRequest(Move(*it));
+ ProcessPendingRequest(std::move(*it));
}
}
AssertMaybeDeferredCountCorrect();
}
bool
MessageChannel::Send(Message* aMsg, Message* aReply)
@@ -1559,17 +1559,17 @@ MessageChannel::Send(Message* aMsg, Mess
MOZ_RELEASE_ASSERT(reply);
MOZ_RELEASE_ASSERT(reply->is_reply(), "expected reply");
MOZ_RELEASE_ASSERT(!reply->is_reply_error());
MOZ_RELEASE_ASSERT(reply->seqno() == seqno);
MOZ_RELEASE_ASSERT(reply->type() == replyType, "wrong reply type");
MOZ_RELEASE_ASSERT(reply->is_sync());
- *aReply = Move(*reply);
+ *aReply = std::move(*reply);
if (aReply->size() >= kMinTelemetryMessageSize) {
Telemetry::Accumulate(Telemetry::IPC_REPLY_SIZE,
nsDependentCString(msgName), aReply->size());
}
// NOTE: Only collect IPC_SYNC_MAIN_LATENCY_MS on the main thread (bug 1343729)
if (NS_IsMainThread() && latencyMs >= kMinTelemetrySyncIPCLatencyMs) {
Telemetry::Accumulate(Telemetry::IPC_SYNC_MAIN_LATENCY_MS,
@@ -1661,36 +1661,36 @@ MessageChannel::Call(Message* aMsg, Mess
}
Message recvd;
MessageMap::iterator it;
if ((it = mOutOfTurnReplies.find(mInterruptStack.top().seqno()))
!= mOutOfTurnReplies.end())
{
- recvd = Move(it->second);
+ recvd = std::move(it->second);
mOutOfTurnReplies.erase(it);
} else if (!mPending.isEmpty()) {
RefPtr<MessageTask> task = mPending.popFirst();
- recvd = Move(task->Msg());
+ recvd = std::move(task->Msg());
if (!IsAlwaysDeferred(recvd)) {
mMaybeDeferredPendingCount--;
}
} else {
// because of subtleties with nested event loops, it's possible
// that we got here and nothing happened. or, we might have a
// deferred in-call that needs to be processed. either way, we
// won't break the inner while loop again until something new
// happens.
continue;
}
// If the message is not Interrupt, we can dispatch it as normal.
if (!recvd.is_interrupt()) {
- DispatchMessage(Move(recvd));
+ DispatchMessage(std::move(recvd));
if (!Connected()) {
ReportConnectionError("MessageChannel::DispatchMessage");
return false;
}
continue;
}
// If the message is an Interrupt reply, either process it as a reply to our
@@ -1703,33 +1703,33 @@ MessageChannel::Call(Message* aMsg, Mess
{
const MessageInfo &outcall = mInterruptStack.top();
// Note, In the parent, sequence numbers increase from 0, and
// in the child, they decrease from 0.
if ((mSide == ChildSide && recvd.seqno() > outcall.seqno()) ||
(mSide != ChildSide && recvd.seqno() < outcall.seqno()))
{
- mOutOfTurnReplies[recvd.seqno()] = Move(recvd);
+ mOutOfTurnReplies[recvd.seqno()] = std::move(recvd);
continue;
}
IPC_ASSERT(recvd.is_reply_error() ||
(recvd.type() == (outcall.type() + 1) &&
recvd.seqno() == outcall.seqno()),
"somebody's misbehavin'", true);
}
// We received a reply to our most recent outstanding call. Pop
// this frame and return the reply.
mInterruptStack.pop();
bool is_reply_error = recvd.is_reply_error();
if (!is_reply_error) {
- *aReply = Move(recvd);
+ *aReply = std::move(recvd);
}
// If we have no more pending out calls waiting on replies, then
// the reply queue should be empty.
IPC_ASSERT(!mInterruptStack.empty() || mOutOfTurnReplies.empty(),
"still have pending replies with no pending out-calls",
true);
@@ -1741,17 +1741,17 @@ MessageChannel::Call(Message* aMsg, Mess
size_t stackDepth = InterruptStackDepth();
{
#ifdef MOZ_TASK_TRACER
Message::AutoTaskTracerRun tasktracerRun(recvd);
#endif
MonitorAutoUnlock unlock(*mMonitor);
CxxStackFrame frame(*this, IN_MESSAGE, &recvd);
- DispatchInterruptMessage(Move(recvd), stackDepth);
+ DispatchInterruptMessage(std::move(recvd), stackDepth);
}
if (!Connected()) {
ReportConnectionError("MessageChannel::DispatchInterruptMessage");
return false;
}
}
return true;
@@ -1805,17 +1805,17 @@ MessageChannel::InterruptEventOccurred()
bool
MessageChannel::ProcessPendingRequest(Message &&aUrgent)
{
AssertWorkerThread();
mMonitor->AssertCurrentThreadOwns();
IPC_LOG("Process pending: seqno=%d, xid=%d", aUrgent.seqno(), aUrgent.transaction_id());
- DispatchMessage(Move(aUrgent));
+ DispatchMessage(std::move(aUrgent));
if (!Connected()) {
ReportConnectionError("MessageChannel::ProcessPendingRequest");
return false;
}
return true;
}
@@ -1900,29 +1900,29 @@ MessageChannel::RunMessage(MessageTask&
if (!IsAlwaysDeferred(msg)) {
mMaybeDeferredPendingCount--;
}
if (IsOnCxxStack() && msg.is_interrupt() && msg.is_reply()) {
// We probably just received a reply in a nested loop for an
// Interrupt call sent before entering that loop.
- mOutOfTurnReplies[msg.seqno()] = Move(msg);
+ mOutOfTurnReplies[msg.seqno()] = std::move(msg);
return;
}
- DispatchMessage(Move(msg));
+ DispatchMessage(std::move(msg));
}
NS_IMPL_ISUPPORTS_INHERITED(MessageChannel::MessageTask, CancelableRunnable, nsIRunnablePriority)
MessageChannel::MessageTask::MessageTask(MessageChannel* aChannel, Message&& aMessage)
: CancelableRunnable(aMessage.name())
, mChannel(aChannel)
- , mMessage(Move(aMessage))
+ , mMessage(std::move(aMessage))
, mScheduled(false)
{
}
nsresult
MessageChannel::MessageTask::Run()
{
if (!mChannel) {
@@ -2056,17 +2056,17 @@ MessageChannel::DispatchMessage(Message
MonitorAutoUnlock unlock(*mMonitor);
CxxStackFrame frame(*this, IN_MESSAGE, &aMsg);
mListener->ArtificialSleep();
if (aMsg.is_sync())
DispatchSyncMessage(aMsg, *getter_Transfers(reply));
else if (aMsg.is_interrupt())
- DispatchInterruptMessage(Move(aMsg), 0);
+ DispatchInterruptMessage(std::move(aMsg), 0);
else
DispatchAsyncMessage(aMsg);
mListener->ArtificialSleep();
}
if (reply && transaction.IsCanceled()) {
// The transaction has been canceled. Don't send a reply.
@@ -2145,17 +2145,17 @@ MessageChannel::DispatchInterruptMessage
mMonitor->AssertNotCurrentThreadOwns();
IPC_ASSERT(aMsg.is_interrupt() && !aMsg.is_reply(), "wrong message type");
if (ShouldDeferInterruptMessage(aMsg, stackDepth)) {
// We now know the other side's stack has one more frame
// than we thought.
++mRemoteStackDepthGuess; // decremented in MaybeProcessDeferred()
- mDeferred.push(Move(aMsg));
+ mDeferred.push(std::move(aMsg));
return;
}
// If we "lost" a race and need to process the other side's in-call, we
// don't need to fix up the mRemoteStackDepthGuess here, because we're just
// about to increment it, which will make it correct again.
#ifdef OS_WIN
@@ -2244,25 +2244,25 @@ MessageChannel::MaybeUndeferIncall()
IPC_ASSERT(deferred.interrupt_remote_stack_depth_guess() <= stackDepth,
"fatal logic error");
if (ShouldDeferInterruptMessage(deferred, stackDepth)) {
return;
}
// maybe time to process this message
- Message call(Move(deferred));
+ Message call(std::move(deferred));
mDeferred.pop();
// fix up fudge factor we added to account for race
IPC_ASSERT(0 < mRemoteStackDepthGuess, "fatal logic error");
--mRemoteStackDepthGuess;
MOZ_RELEASE_ASSERT(call.nested_level() == IPC::Message::NOT_NESTED);
- RefPtr<MessageTask> task = new MessageTask(this, Move(call));
+ RefPtr<MessageTask> task = new MessageTask(this, std::move(call));
mPending.insertBack(task);
MOZ_ASSERT(IsAlwaysDeferred(task->Msg()));
task->Post();
}
void
MessageChannel::EnteredCxxStack()
{
@@ -2699,17 +2699,17 @@ MessageChannel::Close()
{
// We don't use MonitorAutoLock here as that causes some sort of
// deadlock in the error/timeout-with-a-listener state below when
// compiling an optimized msvc build.
mMonitor->Lock();
// Instead just use a ScopeExit to manage the unlock.
RefPtr<RefCountedMonitor> monitor(mMonitor);
- auto exit = MakeScopeExit([m = Move(monitor)] () {
+ auto exit = MakeScopeExit([m = std::move(monitor)] () {
m->Unlock();
});
if (ChannelError == mChannelState || ChannelTimeout == mChannelState) {
// See bug 538586: if the listener gets deleted while the
// IO thread's NotifyChannelError event is still enqueued
// and subsequently deletes us, then the error event will
// also be deleted and the listener will never be notified
@@ -2787,17 +2787,17 @@ MessageChannel::DebugAbort(const char* f
DumpInterruptStack(" ");
printf_stderr(" remote Interrupt stack guess: %zu\n",
mRemoteStackDepthGuess);
printf_stderr(" deferred stack size: %zu\n",
mDeferred.size());
printf_stderr(" out-of-turn Interrupt replies stack size: %zu\n",
mOutOfTurnReplies.size());
- MessageQueue pending = Move(mPending);
+ MessageQueue pending = std::move(mPending);
while (!pending.isEmpty()) {
printf_stderr(" [ %s%s ]\n",
pending.getFirst()->Msg().is_interrupt() ? "intr" :
(pending.getFirst()->Msg().is_sync() ? "sync" : "async"),
pending.getFirst()->Msg().is_reply() ? "reply" : "");
pending.popFirst();
}
@@ -2864,19 +2864,19 @@ MessageChannel::RepostAllMessages()
return;
}
// In some cases we may have deferred dispatch of some messages in the
// queue. Now we want to run them again. However, we can't just re-post
// those messages since the messages after them in mPending would then be
// before them in the event queue. So instead we cancel everything and
// re-post all messages in the correct order.
- MessageQueue queue = Move(mPending);
+ MessageQueue queue = std::move(mPending);
while (RefPtr<MessageTask> task = queue.popFirst()) {
- RefPtr<MessageTask> newTask = new MessageTask(this, Move(task->Msg()));
+ RefPtr<MessageTask> newTask = new MessageTask(this, std::move(task->Msg()));
mPending.insertBack(newTask);
newTask->Post();
}
AssertMaybeDeferredCountCorrect();
}
void
--- a/ipc/glue/MessageChannel.h
+++ b/ipc/glue/MessageChannel.h
@@ -106,17 +106,17 @@ class MessageChannel : HasResultCodes, M
typedef void* ActorIdType;
public:
struct UntypedCallbackHolder
{
UntypedCallbackHolder(ActorIdType aActorId,
RejectCallback&& aReject)
: mActorId(aActorId)
- , mReject(Move(aReject))
+ , mReject(std::move(aReject))
{}
virtual ~UntypedCallbackHolder() {}
void Reject(ResponseRejectReason aReason) {
mReject(aReason);
}
@@ -125,22 +125,22 @@ public:
};
template<typename Value>
struct CallbackHolder : public UntypedCallbackHolder
{
CallbackHolder(ActorIdType aActorId,
ResolveCallback<Value>&& aResolve,
RejectCallback&& aReject)
- : UntypedCallbackHolder(aActorId, Move(aReject))
- , mResolve(Move(aResolve))
+ : UntypedCallbackHolder(aActorId, std::move(aReject))
+ , mResolve(std::move(aResolve))
{}
void Resolve(Value&& aReason) {
- mResolve(Move(aReason));
+ mResolve(std::move(aReason));
}
ResolveCallback<Value> mResolve;
};
private:
static Atomic<size_t> gUnresolvedResponses;
friend class PendingResponseReporter;
@@ -228,18 +228,18 @@ private:
aMsg->set_seqno(seqno);
if (!Send(aMsg)) {
aReject(ResponseRejectReason::SendError);
return;
}
UniquePtr<UntypedCallbackHolder> callback =
MakeUnique<CallbackHolder<Value>>(
- aActorId, Move(aResolve), Move(aReject));
- mPendingResponses.insert(std::make_pair(seqno, Move(callback)));
+ aActorId, std::move(aResolve), std::move(aReject));
+ mPendingResponses.insert(std::make_pair(seqno, std::move(callback)));
gUnresolvedResponses++;
}
bool SendBuildIDsMatchMessage(const char* aParentBuildI);
bool DoBuildIDsMatch() { return mBuildIDsConfirmedMatch; }
// Asynchronously deliver a message back to this side of the
// channel
--- a/ipc/glue/MessageLink.cpp
+++ b/ipc/glue/MessageLink.cpp
@@ -219,30 +219,30 @@ ThreadLink::~ThreadLink()
}
void
ThreadLink::EchoMessage(Message *msg)
{
mChan->AssertWorkerThread();
mChan->mMonitor->AssertCurrentThreadOwns();
- mChan->OnMessageReceivedFromLink(Move(*msg));
+ mChan->OnMessageReceivedFromLink(std::move(*msg));
delete msg;
}
void
ThreadLink::SendMessage(Message *msg)
{
if (!mChan->mIsPostponingSends) {
mChan->AssertWorkerThread();
}
mChan->mMonitor->AssertCurrentThreadOwns();
if (mTargetChan)
- mTargetChan->OnMessageReceivedFromLink(Move(*msg));
+ mTargetChan->OnMessageReceivedFromLink(std::move(*msg));
delete msg;
}
void
ThreadLink::SendClose()
{
mChan->AssertWorkerThread();
mChan->mMonitor->AssertCurrentThreadOwns();
@@ -277,24 +277,24 @@ ThreadLink::Unsound_NumQueuedMessages()
//
void
ProcessLink::OnMessageReceived(Message&& msg)
{
AssertIOThread();
NS_ASSERTION(mChan->mChannelState != ChannelError, "Shouldn't get here!");
MonitorAutoLock lock(*mChan->mMonitor);
- mChan->OnMessageReceivedFromLink(Move(msg));
+ mChan->OnMessageReceivedFromLink(std::move(msg));
}
void
ProcessLink::OnEchoMessage(Message* msg)
{
AssertIOThread();
- OnMessageReceived(Move(*msg));
+ OnMessageReceived(std::move(*msg));
delete msg;
}
void
ProcessLink::OnChannelOpened()
{
AssertIOThread();
@@ -331,17 +331,17 @@ ProcessLink::OnTakeConnectedChannel()
if (mExistingListener) {
mExistingListener->GetQueuedMessages(pending);
}
lock.Notify();
}
// Dispatch whatever messages the previous listener had queued up.
while (!pending.empty()) {
- OnMessageReceived(Move(pending.front()));
+ OnMessageReceived(std::move(pending.front()));
pending.pop();
}
}
void
ProcessLink::OnChannelConnected(int32_t peer_pid)
{
AssertIOThread();
--- a/ipc/glue/ProtocolUtils.h
+++ b/ipc/glue/ProtocolUtils.h
@@ -328,17 +328,17 @@ public:
nsIEventTarget* GetActorEventTarget();
already_AddRefed<nsIEventTarget> GetActorEventTarget(IProtocol* aActor);
protected:
IProtocol(Side aSide, UniquePtr<ProtocolState> aState)
: mId(0)
, mSide(aSide)
, mManager(nullptr)
- , mState(Move(aState))
+ , mState(std::move(aState))
{}
friend class IToplevelProtocol;
void SetId(int32_t aId) { mId = aId; }
void ResetManager() { mManager = nullptr; }
// We have separate functions because the accessibility code manually
// calls SetManager.
@@ -452,17 +452,17 @@ public:
MessageChannel mChannel;
};
using SchedulerGroupSet = nsILabelableRunnable::SchedulerGroupSet;
void SetTransport(UniquePtr<Transport> aTrans)
{
- mTrans = Move(aTrans);
+ mTrans = std::move(aTrans);
}
Transport* GetTransport() const { return mTrans.get(); }
ProtocolId GetProtocolId() const { return mProtocolId; }
base::ProcessId OtherPid() const final;
void SetOtherProcessId(base::ProcessId aOtherPid,
@@ -866,17 +866,17 @@ public:
if (!t) {
return false;
}
if (!aActor->Open(t.get(), mOtherPid, XRE_GetIOMessageLoop(),
mMode == Transport::MODE_SERVER ? ParentSide : ChildSide)) {
return false;
}
mValid = false;
- aActor->SetTransport(Move(t));
+ aActor->SetTransport(std::move(t));
return true;
}
bool IsValid() const {
return mValid;
}
private:
--- a/ipc/ipdl/ipdl/cxx/ast.py
+++ b/ipc/ipdl/ipdl/cxx/ast.py
@@ -681,17 +681,17 @@ class ExprCall(Node):
for arg in args: assert arg and not isinstance(arg, str)
Node.__init__(self)
self.func = func
self.args = args
class ExprMove(ExprCall):
def __init__(self, arg):
- ExprCall.__init__(self, ExprVar("mozilla::Move"), args=[arg])
+ ExprCall.__init__(self, ExprVar("std::move"), args=[arg])
class ExprNew(Node):
# XXX taking some poetic license ...
def __init__(self, ctype, args=[ ], newargs=None):
assert not (ctype.const or ctype.ref)
Node.__init__(self)
self.ctype = ctype
--- a/ipc/ipdl/test/cxx/TestEndpointBridgeMain.cpp
+++ b/ipc/ipdl/test/cxx/TestEndpointBridgeMain.cpp
@@ -142,20 +142,20 @@ TestEndpointBridgeSubParent::RecvBridgeE
nsresult rv;
rv = PTestEndpointBridgeMainSub::CreateEndpoints(
gEndpointBridgeMainChild->OtherPid(), OtherPid(),
&parent, &child);
if (NS_FAILED(rv)) {
fail("opening PTestEndpointOpensOpened");
}
- if (!gEndpointBridgeMainChild->SendBridged(mozilla::Move(parent))) {
+ if (!gEndpointBridgeMainChild->SendBridged(std::move(parent))) {
fail("SendBridge failed for parent");
}
- if (!SendBridged(mozilla::Move(child))) {
+ if (!SendBridged(std::move(child))) {
fail("SendBridge failed for child");
}
return IPC_OK();
}
void
TestEndpointBridgeSubParent::ActorDestroy(ActorDestroyReason why)
--- a/ipc/ipdl/test/cxx/TestEndpointOpens.cpp
+++ b/ipc/ipdl/test/cxx/TestEndpointOpens.cpp
@@ -67,17 +67,17 @@ TestEndpointOpensParent::RecvStartSubpro
gParentThread = new Thread("ParentThread");
if (!gParentThread->Start()) {
fail("starting parent thread");
}
TestEndpointOpensOpenedParent* a = new TestEndpointOpensOpenedParent();
gParentThread->message_loop()->PostTask(
- NewRunnableFunction(OpenParent, a, mozilla::Move(endpoint)));
+ NewRunnableFunction(OpenParent, a, std::move(endpoint)));
return IPC_OK();
}
void
TestEndpointOpensParent::ActorDestroy(ActorDestroyReason why)
{
// Stops the thread and joins it
@@ -188,17 +188,17 @@ TestEndpointOpensChild::RecvStart()
gChildThread = new Thread("ChildThread");
if (!gChildThread->Start()) {
fail("starting child thread");
}
TestEndpointOpensOpenedChild* a = new TestEndpointOpensOpenedChild();
gChildThread->message_loop()->PostTask(
- NewRunnableFunction(OpenChild, a, mozilla::Move(child)));
+ NewRunnableFunction(OpenChild, a, std::move(child)));
if (!SendStartSubprotocol(parent)) {
fail("send StartSubprotocol");
}
return IPC_OK();
}
--- a/ipc/ipdl/test/cxx/TestOffMainThreadPainting.cpp
+++ b/ipc/ipdl/test/cxx/TestOffMainThreadPainting.cpp
@@ -28,21 +28,21 @@ TestOffMainThreadPaintingParent::Main()
OtherPid(),
&parentPipe,
&childPipe);
if (NS_FAILED(rv)) {
fail("create pipes");
}
mPaintActor = new TestPaintThreadParent(this);
- if (!mPaintActor->Bind(Move(parentPipe))) {
+ if (!mPaintActor->Bind(std::move(parentPipe))) {
fail("bind parent pipe");
}
- if (!SendStartTest(Move(childPipe))) {
+ if (!SendStartTest(std::move(childPipe))) {
fail("sending Start");
}
}
ipc::IPCResult
TestOffMainThreadPaintingParent::RecvFinishedLayout(const uint64_t& aTxnId)
{
if (!mPaintedTxn || mPaintedTxn.value() != aTxnId) {
@@ -138,17 +138,17 @@ TestOffMainThreadPaintingChild::RecvStar
{
mPaintThread = MakeUnique<base::Thread>("PaintThread");
if (!mPaintThread->Start()) {
return IPC_FAIL_NO_REASON(this);
}
mPaintActor = new TestPaintThreadChild(GetIPCChannel());
RefPtr<Runnable> task = NewRunnableMethod<ipc::Endpoint<PTestPaintThreadChild>&&>(
- "TestPaintthreadChild::Bind", mPaintActor, &TestPaintThreadChild::Bind, Move(aEndpoint));
+ "TestPaintthreadChild::Bind", mPaintActor, &TestPaintThreadChild::Bind, std::move(aEndpoint));
mPaintThread->message_loop()->PostTask(task.forget());
IssueTransaction();
return IPC_OK();
}
void
TestOffMainThreadPaintingChild::ActorDestroy(ActorDestroyReason aWhy)
--- a/ipc/mscom/ActivationContext.cpp
+++ b/ipc/mscom/ActivationContext.cpp
@@ -185,43 +185,43 @@ ActivationContextRegion::operator=(const
{
Deactivate();
mActCtx = aActCtx;
Activate();
return *this;
}
ActivationContextRegion::ActivationContextRegion(ActivationContext&& aActCtx)
- : mActCtx(Move(aActCtx))
+ : mActCtx(std::move(aActCtx))
, mActCookie(0)
{
Activate();
}
ActivationContextRegion&
ActivationContextRegion::operator=(ActivationContext&& aActCtx)
{
Deactivate();
- mActCtx = Move(aActCtx);
+ mActCtx = std::move(aActCtx);
Activate();
return *this;
}
ActivationContextRegion::ActivationContextRegion(ActivationContextRegion&& aRgn)
- : mActCtx(Move(aRgn.mActCtx))
+ : mActCtx(std::move(aRgn.mActCtx))
, mActCookie(aRgn.mActCookie)
{
aRgn.mActCookie = 0;
}
ActivationContextRegion&
ActivationContextRegion::operator=(ActivationContextRegion&& aRgn)
{
Deactivate();
- mActCtx = Move(aRgn.mActCtx);
+ mActCtx = std::move(aRgn.mActCtx);
mActCookie = aRgn.mActCookie;
aRgn.mActCookie = 0;
return *this;
}
void
ActivationContextRegion::Activate()
{
--- a/ipc/mscom/AgileReference.cpp
+++ b/ipc/mscom/AgileReference.cpp
@@ -59,17 +59,17 @@ AgileReference::AgileReference(REFIID aI
DebugOnly<HRESULT> hr = git->RegisterInterfaceInGlobal(aObject, aIid,
&mGitCookie);
MOZ_ASSERT(SUCCEEDED(hr));
}
AgileReference::AgileReference(AgileReference&& aOther)
: mIid(aOther.mIid)
- , mAgileRef(Move(aOther.mAgileRef))
+ , mAgileRef(std::move(aOther.mAgileRef))
, mGitCookie(aOther.mGitCookie)
{
aOther.mGitCookie = 0;
}
AgileReference::~AgileReference()
{
if (!mGitCookie) {
--- a/ipc/mscom/COMPtrHolder.h
+++ b/ipc/mscom/COMPtrHolder.h
@@ -68,59 +68,59 @@ public:
#if defined(MOZ_CONTENT_SANDBOX)
// This method is const because we need to call it during IPC write, where
// we are passed as a const argument. At higher sandboxing levels we need to
// save this artifact from the serialization process for later deletion.
void PreserveStream(PreservedStreamPtr aPtr) const
{
MOZ_ASSERT(!mMarshaledStream);
- mMarshaledStream = Move(aPtr);
+ mMarshaledStream = std::move(aPtr);
}
PreservedStreamPtr GetPreservedStream()
{
- return Move(mMarshaledStream);
+ return std::move(mMarshaledStream);
}
#endif // defined(MOZ_CONTENT_SANDBOX)
COMPtrHolder(const COMPtrHolder& aOther) = delete;
COMPtrHolder(COMPtrHolder&& aOther)
- : mPtr(Move(aOther.mPtr))
+ : mPtr(std::move(aOther.mPtr))
#if defined(MOZ_CONTENT_SANDBOX)
- , mMarshaledStream(Move(aOther.mMarshaledStream))
+ , mMarshaledStream(std::move(aOther.mMarshaledStream))
#endif // defined(MOZ_CONTENT_SANDBOX)
{
}
// COMPtrHolder is eventually added as a member of a struct that is declared
// in IPDL. The generated C++ code for that IPDL struct includes copy
// constructors and assignment operators that assume that all members are
// copyable. I don't think that those copy constructors and operator= are
// actually used by any generated code, but they are made available. Since no
// move semantics are available, this terrible hack makes COMPtrHolder build
// when used as a member of an IPDL struct.
ThisType& operator=(const ThisType& aOther)
{
- Set(Move(aOther.mPtr));
+ Set(std::move(aOther.mPtr));
#if defined(MOZ_CONTENT_SANDBOX)
- mMarshaledStream = Move(aOther.mMarshaledStream);
+ mMarshaledStream = std::move(aOther.mMarshaledStream);
#endif // defined(MOZ_CONTENT_SANDBOX)
return *this;
}
ThisType& operator=(ThisType&& aOther)
{
- Set(Move(aOther.mPtr));
+ Set(std::move(aOther.mPtr));
#if defined(MOZ_CONTENT_SANDBOX)
- mMarshaledStream = Move(aOther.mMarshaledStream);
+ mMarshaledStream = std::move(aOther.mMarshaledStream);
#endif // defined(MOZ_CONTENT_SANDBOX)
return *this;
}
bool operator==(const ThisType& aOther) const
{
return mPtr == aOther.mPtr;
@@ -215,17 +215,17 @@ struct ParamTraits<mozilla::mscom::COMPt
return false;
}
typename paramType::COMPtrType ptr;
if (!proxyStream.GetInterface(mozilla::mscom::getter_AddRefs(ptr))) {
return false;
}
- aResult->Set(mozilla::Move(ptr));
+ aResult->Set(std::move(ptr));
return true;
}
};
} // namespace IPC
#endif // mozilla_mscom_COMPtrHolder_h
--- a/ipc/mscom/DispatchForwarder.cpp
+++ b/ipc/mscom/DispatchForwarder.cpp
@@ -30,17 +30,17 @@ DispatchForwarder::Create(IInterceptor*
forwarder->Release();
return hr;
}
DispatchForwarder::DispatchForwarder(IInterceptor* aInterceptor,
STAUniquePtr<IDispatch>& aTarget)
: mRefCnt(1)
, mInterceptor(aInterceptor)
- , mTarget(Move(aTarget))
+ , mTarget(std::move(aTarget))
{
}
DispatchForwarder::~DispatchForwarder()
{
}
HRESULT
--- a/ipc/mscom/Interceptor.cpp
+++ b/ipc/mscom/Interceptor.cpp
@@ -54,17 +54,17 @@ public:
void Unlock()
{
mMutex.Unlock();
}
void Put(IUnknown* aKey, already_AddRefed<IWeakReference> aValue)
{
mMutex.AssertCurrentThreadOwns();
- mLiveSet.Put(aKey, Move(aValue));
+ mLiveSet.Put(aKey, std::move(aValue));
}
RefPtr<IWeakReference> Get(IUnknown* aKey)
{
mMutex.AssertCurrentThreadOwns();
RefPtr<IWeakReference> result;
mLiveSet.Get(aKey, getter_AddRefs(result));
return result;
@@ -239,17 +239,17 @@ Interceptor::Create(STAUniquePtr<IUnknow
{
MOZ_ASSERT(aOutInterface && aTarget && aSink);
if (!aOutInterface) {
return E_INVALIDARG;
}
detail::LiveSetAutoLock lock(GetLiveSet());
- RefPtr<IWeakReference> existingWeak(Move(GetLiveSet().Get(aTarget.get())));
+ RefPtr<IWeakReference> existingWeak(std::move(GetLiveSet().Get(aTarget.get())));
if (existingWeak) {
RefPtr<IWeakReferenceSource> existingStrong;
if (SUCCEEDED(existingWeak->ToStrongRef(getter_AddRefs(existingStrong)))) {
// QI on existingStrong may touch other threads. Since we now hold a
// strong ref on the interceptor, we may now release the lock.
lock.Unlock();
return existingStrong->QueryInterface(aInitialIid, aOutInterface);
}
@@ -257,17 +257,17 @@ Interceptor::Create(STAUniquePtr<IUnknow
*aOutInterface = nullptr;
if (!aTarget || !aSink) {
return E_INVALIDARG;
}
RefPtr<Interceptor> intcpt(new Interceptor(aSink));
- return intcpt->GetInitialInterceptorForIID(lock, aInitialIid, Move(aTarget),
+ return intcpt->GetInitialInterceptorForIID(lock, aInitialIid, std::move(aTarget),
aOutInterface);
}
Interceptor::Interceptor(IInterceptorSink* aSink)
: WeakReferenceSupport(WeakReferenceSupport::Flags::eDestroyOnMainThread)
, mEventSink(aSink)
, mInterceptorMapMutex("mozilla::mscom::Interceptor::mInterceptorMapMutex")
, mStdMarshalMutex("mozilla::mscom::Interceptor::mStdMarshalMutex")
@@ -542,17 +542,17 @@ Interceptor::GetInitialInterceptorForIID
MOZ_ASSERT(aTargetIid != IID_IMarshal);
MOZ_ASSERT(!IsProxy(aTarget.get()));
if (aTargetIid == IID_IUnknown) {
// We must lock mInterceptorMapMutex so that nothing can race with us once
// we have been published to the live set.
MutexAutoLock lock(mInterceptorMapMutex);
- HRESULT hr = PublishTarget(aLiveSetLock, nullptr, aTargetIid, Move(aTarget));
+ HRESULT hr = PublishTarget(aLiveSetLock, nullptr, aTargetIid, std::move(aTarget));
ENSURE_HR_SUCCEEDED(hr);
hr = QueryInterface(aTargetIid, aOutInterceptor);
ENSURE_HR_SUCCEEDED(hr);
return hr;
}
// Raise the refcount for stabilization purposes during aggregation
@@ -571,17 +571,17 @@ Interceptor::GetInitialInterceptorForIID
hr = interceptor->RegisterSink(mEventSink);
ENSURE_HR_SUCCEEDED(hr);
// We must lock mInterceptorMapMutex so that nothing can race with us once we have
// been published to the live set.
MutexAutoLock lock(mInterceptorMapMutex);
- hr = PublishTarget(aLiveSetLock, unkInterceptor, aTargetIid, Move(aTarget));
+ hr = PublishTarget(aLiveSetLock, unkInterceptor, aTargetIid, std::move(aTarget));
ENSURE_HR_SUCCEEDED(hr);
if (MarshalAs(aTargetIid) == aTargetIid) {
hr = unkInterceptor->QueryInterface(aTargetIid, aOutInterceptor);
ENSURE_HR_SUCCEEDED(hr);
return hr;
}
@@ -873,17 +873,17 @@ Interceptor::Release()
Interceptor::DisconnectRemotesForTarget(IUnknown* aTarget)
{
MOZ_ASSERT(aTarget);
detail::LiveSetAutoLock lock(GetLiveSet());
// It is not an error if the interceptor doesn't exist, so we return
// S_FALSE instead of an error in that case.
- RefPtr<IWeakReference> existingWeak(Move(GetLiveSet().Get(aTarget)));
+ RefPtr<IWeakReference> existingWeak(std::move(GetLiveSet().Get(aTarget)));
if (!existingWeak) {
return S_FALSE;
}
RefPtr<IWeakReferenceSource> existingStrong;
if (FAILED(existingWeak->ToStrongRef(getter_AddRefs(existingStrong)))) {
return S_FALSE;
}
--- a/ipc/mscom/Interceptor.h
+++ b/ipc/mscom/Interceptor.h
@@ -178,16 +178,16 @@ CreateInterceptor(STAUniquePtr<Interface
{
if (!aTargetInterface || !aEventSink) {
return E_INVALIDARG;
}
REFIID iidTarget = __uuidof(InterfaceT);
STAUniquePtr<IUnknown> targetUnknown(aTargetInterface.release());
- return Interceptor::Create(Move(targetUnknown), aEventSink, iidTarget,
+ return Interceptor::Create(std::move(targetUnknown), aEventSink, iidTarget,
(void**)aOutInterface);
}
} // namespace mscom
} // namespace mozilla
#endif // mozilla_mscom_Interceptor_h
--- a/ipc/mscom/InterceptorLog.cpp
+++ b/ipc/mscom/InterceptorLog.cpp
@@ -304,17 +304,17 @@ Logger::LogQI(HRESULT aResult, IUnknown*
if (StringFromGUID2(aIid, buf, mozilla::ArrayLength(buf))) {
line.AppendPrintf("%S", buf);
} else {
line.AppendLiteral("(IID Conversion Failed)");
}
line.AppendPrintf(", [out] 0x%p)\t0x%08X\n", aInterface, aResult);
MutexAutoLock lock(mMutex);
- mEntries.AppendElement(Move(line));
+ mEntries.AppendElement(std::move(line));
mThread->Dispatch(NewNonOwningRunnableMethod("Logger::Flush",
this, &Logger::Flush),
NS_DISPATCH_NORMAL);
}
bool
Logger::TryParamAsGuid(REFIID aIid, ICallFrame* aCallFrame,
const CALLFRAMEPARAMINFO& aParamInfo, nsACString& aLine)
@@ -414,17 +414,17 @@ Logger::CaptureFrame(ICallFrame* aCallFr
line.AppendLiteral(", ");
}
}
line.AppendLiteral(")\t");
HRESULT callResult = aCallFrame->GetReturnValue();
line.AppendPrintf("0x%08X\n", callResult);
- aCapturedFrame = Move(line);
+ aCapturedFrame = std::move(line);
}
void
Logger::LogEvent(const nsACString& aCapturedFrame,
const TimeDuration& aOverheadDuration,
const TimeDuration& aGeckoDuration)
{
double elapsed = GetElapsedTime();
--- a/ipc/mscom/MainThreadHandoff.cpp
+++ b/ipc/mscom/MainThreadHandoff.cpp
@@ -714,17 +714,17 @@ MainThreadHandoff::OnWalkInterface(REFII
if (FAILED(hr)) {
return hr;
}
REFIID interceptorIid = payload ? payload->MarshalAs(effectiveIid) :
effectiveIid;
RefPtr<IUnknown> wrapped;
- hr = Interceptor::Create(Move(origInterface), handoff, interceptorIid,
+ hr = Interceptor::Create(std::move(origInterface), handoff, interceptorIid,
getter_AddRefs(wrapped));
MOZ_ASSERT(SUCCEEDED(hr));
if (FAILED(hr)) {
return hr;
}
// And replace the original interface pointer with the wrapped one.
wrapped.forget(reinterpret_cast<IUnknown**>(aInterface));
--- a/ipc/mscom/MainThreadHandoff.h
+++ b/ipc/mscom/MainThreadHandoff.h
@@ -26,33 +26,33 @@ class MainThreadHandoff final : public I
public:
static HRESULT Create(IHandlerProvider* aHandlerProvider,
IInterceptorSink** aOutput);
template <typename Interface>
static HRESULT WrapInterface(STAUniquePtr<Interface> aTargetInterface,
Interface** aOutInterface)
{
- return WrapInterface<Interface>(Move(aTargetInterface), nullptr,
+ return WrapInterface<Interface>(std::move(aTargetInterface), nullptr,
aOutInterface);
}
template <typename Interface>
static HRESULT WrapInterface(STAUniquePtr<Interface> aTargetInterface,
IHandlerProvider* aHandlerProvider,
Interface** aOutInterface)
{
MOZ_ASSERT(!IsProxy(aTargetInterface.get()));
RefPtr<IInterceptorSink> handoff;
HRESULT hr = MainThreadHandoff::Create(aHandlerProvider,
getter_AddRefs(handoff));
if (FAILED(hr)) {
return hr;
}
- return CreateInterceptor(Move(aTargetInterface), handoff, aOutInterface);
+ return CreateInterceptor(std::move(aTargetInterface), handoff, aOutInterface);
}
// IUnknown
STDMETHODIMP QueryInterface(REFIID riid, void** ppv) override;
STDMETHODIMP_(ULONG) AddRef() override;
STDMETHODIMP_(ULONG) Release() override;
// ICallFrameEvents
--- a/ipc/mscom/MainThreadInvoker.cpp
+++ b/ipc/mscom/MainThreadInvoker.cpp
@@ -131,17 +131,17 @@ MainThreadInvoker::MainThreadInvoker()
{
static const bool gotStatics = InitStatics();
MOZ_ASSERT(gotStatics);
}
bool
MainThreadInvoker::Invoke(already_AddRefed<nsIRunnable>&& aRunnable)
{
- nsCOMPtr<nsIRunnable> runnable(Move(aRunnable));
+ nsCOMPtr<nsIRunnable> runnable(std::move(aRunnable));
if (!runnable) {
return false;
}
if (NS_IsMainThread()) {
runnable->Run();
return true;
}
--- a/ipc/mscom/PassthruProxy.cpp
+++ b/ipc/mscom/PassthruProxy.cpp
@@ -29,17 +29,17 @@ PassthruProxy::PassthruProxy(ProxyStream
: mRefCnt(0)
, mWrappedIid(aIidToWrap)
, mVTableSize(aVTableSize)
, mVTable(nullptr)
, mForgetPreservedStream(false)
{
ProxyStream proxyStream(aIidToWrap, aObjToWrap, aEnv,
ProxyStreamFlags::ePreservable);
- mPreservedStream = Move(proxyStream.GetPreservedStream());
+ mPreservedStream = std::move(proxyStream.GetPreservedStream());
MOZ_ASSERT(mPreservedStream);
}
PassthruProxy::~PassthruProxy()
{
if (mForgetPreservedStream) {
// We want to release the ref without clearing marshal data
IStream* stream = mPreservedStream.release();
--- a/ipc/mscom/ProxyStream.cpp
+++ b/ipc/mscom/ProxyStream.cpp
@@ -168,40 +168,40 @@ ProxyStream::ProxyStream(REFIID aIID, co
}
ProxyStream::ProxyStream(ProxyStream&& aOther)
: mGlobalLockedBuf(nullptr)
, mHGlobal(nullptr)
, mBufSize(0)
, mPreserveStream(false)
{
- *this = mozilla::Move(aOther);
+ *this = std::move(aOther);
}
ProxyStream&
ProxyStream::operator=(ProxyStream&& aOther)
{
if (mHGlobal && mGlobalLockedBuf) {
DebugOnly<BOOL> result = ::GlobalUnlock(mHGlobal);
MOZ_ASSERT(!result && ::GetLastError() == NO_ERROR);
}
- mStream = Move(aOther.mStream);
+ mStream = std::move(aOther.mStream);
mGlobalLockedBuf = aOther.mGlobalLockedBuf;
aOther.mGlobalLockedBuf = nullptr;
// ::GlobalFree() was called implicitly when mStream was replaced.
mHGlobal = aOther.mHGlobal;
aOther.mHGlobal = nullptr;
mBufSize = aOther.mBufSize;
aOther.mBufSize = 0;
- mUnmarshaledProxy = Move(aOther.mUnmarshaledProxy);
+ mUnmarshaledProxy = std::move(aOther.mUnmarshaledProxy);
mPreserveStream = aOther.mPreserveStream;
return *this;
}
ProxyStream::~ProxyStream()
{
if (mHGlobal && mGlobalLockedBuf) {
@@ -252,17 +252,17 @@ ProxyStream::GetPreservedStream()
LARGE_INTEGER pos;
pos.QuadPart = 0LL;
hr = cloned->Seek(pos, STREAM_SEEK_SET, nullptr);
if (FAILED(hr)) {
return nullptr;
}
mPreserveStream = false;
- return ToPreservedStreamPtr(Move(cloned));
+ return ToPreservedStreamPtr(std::move(cloned));
}
bool
ProxyStream::GetInterface(void** aOutInterface)
{
// We should not have a locked buffer on this side
MOZ_ASSERT(!mGlobalLockedBuf);
MOZ_ASSERT(aOutInterface);
@@ -382,17 +382,17 @@ ProxyStream::ProxyStream(REFIID aIID, IU
if (FAILED(getHGlobalResult)) {
nsPrintfCString hrAsStr("0x%08X", getHGlobalResult);
CrashReporter::AnnotateCrashReport(
NS_LITERAL_CSTRING("GetHGlobalFromStreamFailure"),
hrAsStr);
}
- mStream = mozilla::Move(stream);
+ mStream = std::move(stream);
if (streamSize) {
CrashReporter::AnnotateCrashReport(NS_LITERAL_CSTRING("ProxyStreamSizeFrom"),
NS_LITERAL_CSTRING("IStream::Stat"));
mBufSize = streamSize;
}
if (!hglobal) {
--- a/ipc/mscom/Ptr.h
+++ b/ipc/mscom/Ptr.h
@@ -231,17 +231,17 @@ ToSTAUniquePtr(T* aRawPtr)
}
template <typename T, typename U>
inline STAUniquePtr<T>
ToSTAUniquePtr(const InterceptorTargetPtr<U>& aTarget)
{
MOZ_ASSERT(NS_IsMainThread());
RefPtr<T> newRef(static_cast<T*>(aTarget.get()));
- return ToSTAUniquePtr(Move(newRef));
+ return ToSTAUniquePtr(std::move(newRef));
}
template <typename T>
inline MTAUniquePtr<T>
ToMTAUniquePtr(RefPtr<T>&& aRefPtr)
{
return MTAUniquePtr<T>(aRefPtr.forget().take());
}
--- a/ipc/mscom/Utils.cpp
+++ b/ipc/mscom/Utils.cpp
@@ -327,17 +327,17 @@ IsInterfaceEqualToOrInheritedFrom(REFIID
// We expect this array to be length 1 but that is not guaranteed by the API.
AutoTArray<RefPtr<ITypeInfo>, 1> typeInfos;
// Grab aInterface's ITypeInfo so that we may obtain information about its
// inheritance hierarchy.
RefPtr<ITypeInfo> typeInfo;
if (RegisteredProxy::Find(aInterface, getter_AddRefs(typeInfo))) {
- typeInfos.AppendElement(Move(typeInfo));
+ typeInfos.AppendElement(std::move(typeInfo));
}
/**
* The main loop of this function searches the hierarchy of aInterface's
* parent interfaces, searching for aFrom.
*/
while (!typeInfos.IsEmpty()) {
RefPtr<ITypeInfo> curTypeInfo(typeInfos.PopLastElement());
@@ -388,17 +388,17 @@ IsInterfaceEqualToOrInheritedFrom(REFIID
nextTypeInfo->ReleaseTypeAttr(typeAttr);
typeAttr = nullptr;
if (nextIid == aFrom) {
return true;
}
- typeInfos.AppendElement(Move(nextTypeInfo));
+ typeInfos.AppendElement(std::move(nextTypeInfo));
}
}
return false;
}
#endif // defined(MOZILLA_INTERNAL_API)
--- a/js/ipc/JavaScriptBase.h
+++ b/js/ipc/JavaScriptBase.h
@@ -102,17 +102,17 @@ class JavaScriptBase : public WrapperOwn
if (!Answer::RecvIsExtensible(ObjectId::deserialize(objId), rs, result)) {
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();
}
mozilla::ipc::IPCResult RecvCallOrConstruct(const uint64_t& objId, InfallibleTArray<JSParam>&& argv,
const bool& construct, ReturnStatus* rs, JSVariant* result,
nsTArray<JSParam>* outparams) override {
- if (!Answer::RecvCallOrConstruct(ObjectId::deserialize(objId), Move(argv), construct, rs, result, outparams)) {
+ if (!Answer::RecvCallOrConstruct(ObjectId::deserialize(objId), std::move(argv), construct, rs, result, outparams)) {
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();
}
mozilla::ipc::IPCResult RecvHasInstance(const uint64_t& objId, const JSVariant& v, ReturnStatus* rs, bool* bp) override {
if (!Answer::RecvHasInstance(ObjectId::deserialize(objId), v, rs, bp)) {
return IPC_FAIL_NO_REASON(this);
}
--- a/js/public/GCHashTable.h
+++ b/js/public/GCHashTable.h
@@ -81,20 +81,20 @@ class GCHashMap : public js::HashMap<Key
for (typename Base::Enum e(*this); !e.empty(); e.popFront()) {
if (MapSweepPolicy::needsSweep(&e.front().mutableKey(), &e.front().value()))
e.removeFront();
}
}
// GCHashMap is movable
- GCHashMap(GCHashMap&& rhs) : Base(mozilla::Move(rhs)) {}
+ GCHashMap(GCHashMap&& rhs) : Base(std::move(rhs)) {}
void operator=(GCHashMap&& rhs) {
MOZ_ASSERT(this != &rhs, "self-move assignment is prohibited");
- Base::operator=(mozilla::Move(rhs));
+ Base::operator=(std::move(rhs));
}
private:
// GCHashMap is not copyable or assignable
GCHashMap(const GCHashMap& hm) = delete;
GCHashMap& operator=(const GCHashMap& hm) = delete;
};
@@ -128,20 +128,20 @@ class GCRekeyableHashMap : public JS::GC
if (MapSweepPolicy::needsSweep(&key, &e.front().value()))
e.removeFront();
else if (!HashPolicy::match(key, e.front().key()))
e.rekeyFront(key);
}
}
// GCRekeyableHashMap is movable
- GCRekeyableHashMap(GCRekeyableHashMap&& rhs) : Base(mozilla::Move(rhs)) {}
+ GCRekeyableHashMap(GCRekeyableHashMap&& rhs) : Base(std::move(rhs)) {}
void operator=(GCRekeyableHashMap&& rhs) {
MOZ_ASSERT(this != &rhs, "self-move assignment is prohibited");
- Base::operator=(mozilla::Move(rhs));
+ Base::operator=(std::move(rhs));
}
};
template <typename Wrapper, typename... Args>
class WrappedPtrOperations<JS::GCHashMap<Args...>, Wrapper>
{
using Map = JS::GCHashMap<Args...>;
using Lookup = typename Map::Lookup;
@@ -261,20 +261,20 @@ class GCHashSet : public js::HashSet<T,
return;
for (typename Base::Enum e(*this); !e.empty(); e.popFront()) {
if (GCPolicy<T>::needsSweep(&e.mutableFront()))
e.removeFront();
}
}
// GCHashSet is movable
- GCHashSet(GCHashSet&& rhs) : Base(mozilla::Move(rhs)) {}
+ GCHashSet(GCHashSet&& rhs) : Base(std::move(rhs)) {}
void operator=(GCHashSet&& rhs) {
MOZ_ASSERT(this != &rhs, "self-move assignment is prohibited");
- Base::operator=(mozilla::Move(rhs));
+ Base::operator=(std::move(rhs));
}
private:
// GCHashSet is not copyable or assignable
GCHashSet(const GCHashSet& hs) = delete;
GCHashSet& operator=(const GCHashSet& hs) = delete;
};
--- a/js/public/GCVector.h
+++ b/js/public/GCVector.h
@@ -38,21 +38,21 @@ class GCVector
mozilla::Vector<T, MinInlineCapacity, AllocPolicy> vector;
public:
explicit GCVector(AllocPolicy alloc = AllocPolicy())
: vector(alloc)
{}
GCVector(GCVector&& vec)
- : vector(mozilla::Move(vec.vector))
+ : vector(std::move(vec.vector))
{}
GCVector& operator=(GCVector&& vec) {
- vector = mozilla::Move(vec.vector);
+ vector = std::move(vec.vector);
return *this;
}
size_t length() const { return vector.length(); }
bool empty() const { return vector.empty(); }
size_t capacity() const { return vector.capacity(); }
T* begin() { return vector.begin(); }
--- a/js/public/HashTable.h
+++ b/js/public/HashTable.h
@@ -288,20 +288,20 @@ class HashMap
if (Ptr p = lookup(old_lookup)) {
impl.rekeyAndMaybeRehash(p, new_lookup, new_key);
return true;
}
return false;
}
// HashMap is movable
- HashMap(HashMap&& rhs) : impl(mozilla::Move(rhs.impl)) {}
+ HashMap(HashMap&& rhs) : impl(std::move(rhs.impl)) {}
void operator=(HashMap&& rhs) {
MOZ_ASSERT(this != &rhs, "self-move assignment is prohibited");
- impl = mozilla::Move(rhs.impl);
+ impl = std::move(rhs.impl);
}
private:
// HashMap is not copyable or assignable
HashMap(const HashMap& hm) = delete;
HashMap& operator=(const HashMap& hm) = delete;
friend class Impl::Enum;
@@ -536,20 +536,20 @@ class HashSet
MOZ_ASSERT(p.found());
MOZ_ASSERT(*p != new_value);
MOZ_ASSERT(HashPolicy::hash(*p) == HashPolicy::hash(new_value));
MOZ_ASSERT(HashPolicy::match(*p, new_value));
const_cast<T&>(*p) = new_value;
}
// HashSet is movable
- HashSet(HashSet&& rhs) : impl(mozilla::Move(rhs.impl)) {}
+ HashSet(HashSet&& rhs) : impl(std::move(rhs.impl)) {}
void operator=(HashSet&& rhs) {
MOZ_ASSERT(this != &rhs, "self-move assignment is prohibited");
- impl = mozilla::Move(rhs.impl);
+ impl = std::move(rhs.impl);
}
private:
// HashSet is not copyable or assignable
HashSet(const HashSet& hs) = delete;
HashSet& operator=(const HashSet& hs) = delete;
friend class Impl::Enum;
@@ -638,17 +638,17 @@ struct DefaultHasher<mozilla::UniquePtr<
static HashNumber hash(const Lookup& l) {
return PtrHasher::hash(l.get());
}
static bool match(const mozilla::UniquePtr<T, D>& k, const Lookup& l) {
return PtrHasher::match(k.get(), l.get());
}
static void rekey(mozilla::UniquePtr<T, D>& k, mozilla::UniquePtr<T, D>&& newKey) {
- k = mozilla::Move(newKey);
+ k = std::move(newKey);
}
};
// For doubles, we can xor the two uint32s.
template <>
struct DefaultHasher<double>
{
typedef double Lookup;
@@ -741,23 +741,23 @@ class HashMapEntry
public:
template<typename KeyInput, typename ValueInput>
HashMapEntry(KeyInput&& k, ValueInput&& v)
: key_(mozilla::Forward<KeyInput>(k)),
value_(mozilla::Forward<ValueInput>(v))
{}
HashMapEntry(HashMapEntry&& rhs)
- : key_(mozilla::Move(rhs.key_)),
- value_(mozilla::Move(rhs.value_))
+ : key_(std::move(rhs.key_)),
+ value_(std::move(rhs.value_))
{}
void operator=(HashMapEntry&& rhs) {
- key_ = mozilla::Move(rhs.key_);
- value_ = mozilla::Move(rhs.value_);
+ key_ = std::move(rhs.key_);
+ value_ = std::move(rhs.value_);
}
typedef Key KeyType;
typedef Value ValueType;
const Key& key() const { return key_; }
Key& mutableKey() { return key_; }
const Value& value() const { return value_; }
@@ -841,17 +841,17 @@ class HashTableEntry
void swap(HashTableEntry* other) {
if (this == other)
return;
MOZ_ASSERT(isLive());
if (other->isLive()) {
mozilla::Swap(*valuePtr(), *other->valuePtr());
} else {
- *other->valuePtr() = mozilla::Move(*valuePtr());
+ *other->valuePtr() = std::move(*valuePtr());
destroy();
}
mozilla::Swap(keyHash, other->keyHash);
}
T& get() {
MOZ_ASSERT(isLive());
return *valuePtr();
@@ -1575,17 +1575,17 @@ class HashTable : private AllocPolicy
table = newTable;
// Copy only live entries, leaving removed ones behind.
Entry* end = oldTable + oldCap;
for (Entry* src = oldTable; src < end; ++src) {
if (src->isLive()) {
HashNumber hn = src->getKeyHash();
findFreeEntry(hn).setLive(
- hn, mozilla::Move(const_cast<typename Entry::NonConstT&>(src->get())));
+ hn, std::move(const_cast<typename Entry::NonConstT&>(src->get())));
}
src->~Entry();
}
// All entries have been destroyed, no need to destroyTable.
this->free_(oldTable);
return Rehashed;
@@ -1950,20 +1950,20 @@ class HashTable : private AllocPolicy
}
void rekeyWithoutRehash(Ptr p, const Lookup& l, const Key& k)
{
MOZ_ASSERT(table);
mozilla::ReentrancyGuard g(*this);
MOZ_ASSERT(p.found());
MOZ_ASSERT(p.generation == generation());
- typename HashTableEntry<T>::NonConstT t(mozilla::Move(*p));
+ typename HashTableEntry<T>::NonConstT t(std::move(*p));
HashPolicy::setKey(t, const_cast<Key&>(k));
remove(*p.entry_);
- putNewInfallibleInternal(l, mozilla::Move(t));
+ putNewInfallibleInternal(l, std::move(t));
}
void rekeyAndMaybeRehash(Ptr p, const Lookup& l, const Key& k)
{
rekeyWithoutRehash(p, l, k);
checkOverRemoved();
}
--- a/js/public/MemoryMetrics.h
+++ b/js/public/MemoryMetrics.h
@@ -721,22 +721,22 @@ struct ZoneStats
extra(),
allStrings(nullptr),
notableStrings(),
isTotals(true)
{}
ZoneStats(ZoneStats&& other)
: FOR_EACH_SIZE(COPY_OTHER_SIZE)
- unusedGCThings(mozilla::Move(other.unusedGCThings)),
- stringInfo(mozilla::Move(other.stringInfo)),
- shapeInfo(mozilla::Move(other.shapeInfo)),
+ unusedGCThings(std::move(other.unusedGCThings)),
+ stringInfo(std::move(other.stringInfo)),
+ shapeInfo(std::move(other.shapeInfo)),
extra(other.extra),
allStrings(other.allStrings),
- notableStrings(mozilla::Move(other.notableStrings)),
+ notableStrings(std::move(other.notableStrings)),
isTotals(other.isTotals)
{
other.allStrings = nullptr;
MOZ_ASSERT(!other.isTotals);
}
~ZoneStats() {
// |allStrings| is usually deleted and set to nullptr before this
@@ -841,20 +841,20 @@ struct RealmStats
extra(),
allClasses(nullptr),
notableClasses(),
isTotals(true)
{}
RealmStats(RealmStats&& other)
: FOR_EACH_SIZE(COPY_OTHER_SIZE)
- classInfo(mozilla::Move(other.classInfo)),
+ classInfo(std::move(other.classInfo)),
extra(other.extra),
allClasses(other.allClasses),
- notableClasses(mozilla::Move(other.notableClasses)),
+ notableClasses(std::move(other.notableClasses)),
isTotals(other.isTotals)
{
other.allClasses = nullptr;
MOZ_ASSERT(!other.isTotals);
}
RealmStats(const RealmStats&) = delete; // disallow copying
--- a/js/public/RootingAPI.h
+++ b/js/public/RootingAPI.h
@@ -165,17 +165,17 @@ struct PersistentRootedMarker;
// operator= on the derived class. Thus, define the operator= directly on the
// class as we would need to manually pass it through anyway.
#define DECLARE_POINTER_ASSIGN_OPS(Wrapper, T) \
Wrapper<T>& operator=(const T& p) { \
set(p); \
return *this; \
} \
Wrapper<T>& operator=(T&& p) { \
- set(mozilla::Move(p)); \
+ set(std::move(p)); \
return *this; \
} \
Wrapper<T>& operator=(const Wrapper<T>& other) { \
set(other.get()); \
return *this; \
} \
#define DELETE_ASSIGNMENT_OPS(Wrapper, T) \
@@ -609,17 +609,17 @@ class MOZ_STACK_CLASS MutableHandle : pu
MutableHandle(decltype(nullptr)) = delete;
public:
void set(const T& v) {
*ptr = v;
MOZ_ASSERT(GCPolicy<T>::isValid(*ptr));
}
void set(T&& v) {
- *ptr = mozilla::Move(v);
+ *ptr = std::move(v);
MOZ_ASSERT(GCPolicy<T>::isValid(*ptr));
}
/*
* This may be called only if the location of the T is guaranteed
* to be marked (for some reason other than being a Rooted),
* e.g., if it is guaranteed to be reachable from an implicit root.
*
@@ -1012,17 +1012,17 @@ class MOZ_RAII Rooted : public js::Roote
* This method is public for Rooted so that Codegen.py can use a Rooted
* interchangeably with a MutableHandleValue.
*/
void set(const T& value) {
ptr = value;
MOZ_ASSERT(GCPolicy<T>::isValid(ptr));
}
void set(T&& value) {
- ptr = mozilla::Move(value);
+ ptr = std::move(value);
MOZ_ASSERT(GCPolicy<T>::isValid(ptr));
}
DECLARE_POINTER_CONSTREF_OPS(T);
DECLARE_POINTER_ASSIGN_OPS(Rooted, T);
DECLARE_NONPOINTER_ACCESSOR_METHODS(ptr);
DECLARE_NONPOINTER_MUTABLE_ACCESSOR_METHODS(ptr);
--- a/js/public/StructuredClone.h
+++ b/js/public/StructuredClone.h
@@ -417,24 +417,24 @@ class MOZ_NON_MEMMOVABLE JS_PUBLIC_API(J
, callbacks_(nullptr)
, closure_(nullptr)
, ownTransferables_(OwnTransferablePolicy::NoTransferables)
{}
// Steal the raw data from a BufferList. In this case, we don't know the
// scope and none of the callback info is assigned yet.
JSStructuredCloneData(BufferList&& buffers, JS::StructuredCloneScope scope)
- : bufList_(mozilla::Move(buffers))
+ : bufList_(std::move(buffers))
, scope_(scope)
, callbacks_(nullptr)
, closure_(nullptr)
, ownTransferables_(OwnTransferablePolicy::NoTransferables)
{}
MOZ_IMPLICIT JSStructuredCloneData(BufferList&& buffers)
- : JSStructuredCloneData(mozilla::Move(buffers), JS::StructuredCloneScope::Unassigned)
+ : JSStructuredCloneData(std::move(buffers), JS::StructuredCloneScope::Unassigned)
{}
JSStructuredCloneData(JSStructuredCloneData&& other) = default;
JSStructuredCloneData& operator=(JSStructuredCloneData&& other) = default;
~JSStructuredCloneData() { discardTransferables(); }
void setCallbacks(const JSStructuredCloneCallbacks* callbacks,
void* closure,
OwnTransferablePolicy policy)
--- a/js/public/UbiNode.h
+++ b/js/public/UbiNode.h
@@ -839,35 +839,35 @@ class Edge {
// Construct an initialized Edge, taking ownership of |name|.
Edge(char16_t* name, const Node& referent)
: name(name)
, referent(referent)
{ }
// Move construction and assignment.
Edge(Edge&& rhs)
- : name(mozilla::Move(rhs.name))
+ : name(std::move(rhs.name))
, referent(rhs.referent)
{ }
Edge& operator=(Edge&& rhs) {
MOZ_ASSERT(&rhs != this);
this->~Edge();
- new (this) Edge(mozilla::Move(rhs));
+ new (this) Edge(std::move(rhs));
return *this;
}
Edge(const Edge&) = delete;
Edge& operator=(const Edge&) = delete;
// This edge's name. This may be nullptr, if Node::edges was called with
// false as the wantNames parameter.
//
// The storage is owned by this Edge, and will be freed when this Edge is
- // destructed. You may take ownership of the name by `mozilla::Move`ing it
+ // destructed. You may take ownership of the name by `std::move`ing it
// out of the edge; it is just a UniquePtr.
//
// (In real life we'll want a better representation for names, to avoid
// creating tons of strings when the names follow a pattern; and we'll need
// to think about lifetimes carefully to ensure traversal stays cheap.)
EdgeName name;
// This edge's referent.
--- a/js/public/UbiNodeCensus.h
+++ b/js/public/UbiNodeCensus.h
@@ -180,17 +180,17 @@ class CountBase {
class RootedCount : JS::CustomAutoRooter {
CountBasePtr count;
void trace(JSTracer* trc) override { count->trace(trc); }
public:
RootedCount(JSContext* cx, CountBasePtr&& count)
: CustomAutoRooter(cx),
- count(Move(count))
+ count(std::move(count))
{ }
CountBase* operator->() const { return count.get(); }
explicit operator bool() const { return count.get(); }
operator CountBasePtr&() { return count; }
};
// Common data for a census traversal, shared across all CountType nodes.
struct Census {
--- a/js/public/UbiNodeDominatorTree.h
+++ b/js/public/UbiNodeDominatorTree.h
@@ -177,35 +177,35 @@ class JS_PUBLIC_API(DominatorTree)
* individual set.
*/
class DominatedSets
{
JS::ubi::Vector<uint32_t> dominated;
JS::ubi::Vector<uint32_t> indices;
DominatedSets(JS::ubi::Vector<uint32_t>&& dominated, JS::ubi::Vector<uint32_t>&& indices)
- : dominated(mozilla::Move(dominated))
- , indices(mozilla::Move(indices))
+ : dominated(std::move(dominated))
+ , indices(std::move(indices))
{ }
public:
// DominatedSets is not copy-able.
DominatedSets(const DominatedSets& rhs) = delete;
DominatedSets& operator=(const DominatedSets& rhs) = delete;
// DominatedSets is move-able.
DominatedSets(DominatedSets&& rhs)
- : dominated(mozilla::Move(rhs.dominated))
- , indices(mozilla::Move(rhs.indices))
+ : dominated(std::move(rhs.dominated))
+ , indices(std::move(rhs.indices))
{
MOZ_ASSERT(this != &rhs, "self-move not allowed");
}
DominatedSets& operator=(DominatedSets&& rhs) {
this->~DominatedSets();
- new (this) DominatedSets(mozilla::Move(rhs));
+ new (this) DominatedSets(std::move(rhs));
return *this;
}
/**
* Create the DominatedSets given the mapping of a node index to its
* immediate dominator. Returns `Some` on success, `Nothing` on OOM
* failure.
*/
@@ -265,17 +265,17 @@ class JS_PUBLIC_API(DominatorTree)
uint32_t lastIndex = 0;
for (uint32_t i = 0; i < length; i++) {
MOZ_ASSERT(indices[i] >= lastIndex);
MOZ_ASSERT(indices[i] < length);
lastIndex = indices[i];
}
#endif
- return mozilla::Some(DominatedSets(mozilla::Move(dominated), mozilla::Move(indices)));
+ return mozilla::Some(DominatedSets(std::move(dominated), std::move(indices)));
}
/**
* Get the set of nodes immediately dominated by the node at
* `postOrder[nodeIndex]`.
*/
DominatedSetRange dominatedSet(JS::ubi::Vector<Node>& postOrder, uint32_t nodeIndex) const {
MOZ_ASSERT(postOrder.length() == indices.length());
@@ -298,20 +298,20 @@ class JS_PUBLIC_API(DominatorTree)
private:
// We use `UNDEFINED` as a sentinel value in the `doms` vector to signal
// that we haven't found any dominators for the node at the corresponding
// index in `postOrder` yet.
static const uint32_t UNDEFINED = UINT32_MAX;
DominatorTree(JS::ubi::Vector<Node>&& postOrder, NodeToIndexMap&& nodeToPostOrderIndex,
JS::ubi::Vector<uint32_t>&& doms, DominatedSets&& dominatedSets)
- : postOrder(mozilla::Move(postOrder))
- , nodeToPostOrderIndex(mozilla::Move(nodeToPostOrderIndex))
- , doms(mozilla::Move(doms))
- , dominatedSets(mozilla::Move(dominatedSets))
+ : postOrder(std::move(postOrder))
+ , nodeToPostOrderIndex(std::move(nodeToPostOrderIndex))
+ , doms(std::move(doms))
+ , dominatedSets(std::move(dominatedSets))
, retainedSizes(mozilla::Nothing())
{ }
static uint32_t intersect(JS::ubi::Vector<uint32_t>& doms, uint32_t finger1, uint32_t finger2) {
while (finger1 != finger2) {
if (finger1 < finger2)
finger1 = doms[finger1];
else if (finger2 < finger1)
@@ -334,17 +334,17 @@ class JS_PUBLIC_API(DominatorTree)
};
auto onEdge = [&](const Node& origin, const Edge& edge) {
auto p = predecessorSets.lookupForAdd(edge.referent);
if (!p) {
mozilla::UniquePtr<NodeSet, DeletePolicy<NodeSet>> set(js_new<NodeSet>());
if (!set ||
!set->init() ||
- !predecessorSets.add(p, edge.referent, mozilla::Move(set)))
+ !predecessorSets.add(p, edge.referent, std::move(set)))
{
return false;
}
}
MOZ_ASSERT(p && p->value());
return p->value()->put(origin);
};
@@ -468,27 +468,27 @@ class JS_PUBLIC_API(DominatorTree)
public:
// DominatorTree is not copy-able.
DominatorTree(const DominatorTree&) = delete;
DominatorTree& operator=(const DominatorTree&) = delete;
// DominatorTree is move-able.
DominatorTree(DominatorTree&& rhs)
- : postOrder(mozilla::Move(rhs.postOrder))
- , nodeToPostOrderIndex(mozilla::Move(rhs.nodeToPostOrderIndex))
- , doms(mozilla::Move(rhs.doms))
- , dominatedSets(mozilla::Move(rhs.dominatedSets))
- , retainedSizes(mozilla::Move(rhs.retainedSizes))
+ : postOrder(std::move(rhs.postOrder))
+ , nodeToPostOrderIndex(std::move(rhs.nodeToPostOrderIndex))
+ , doms(std::move(rhs.doms))
+ , dominatedSets(std::move(rhs.dominatedSets))
+ , retainedSizes(std::move(rhs.retainedSizes))
{
MOZ_ASSERT(this != &rhs, "self-move is not allowed");
}
DominatorTree& operator=(DominatorTree&& rhs) {
this->~DominatorTree();
- new (this) DominatorTree(mozilla::Move(rhs));
+ new (this) DominatorTree(std::move(rhs));
return *this;
}
/**
* Construct a `DominatorTree` of the heap graph visible from `root`. The
* `root` is also used as the root of the resulting dominator tree.
*
* The resulting `DominatorTree` instance must not outlive the
@@ -585,20 +585,20 @@ class JS_PUBLIC_API(DominatorTree)
}
}
}
auto maybeDominatedSets = DominatedSets::Create(doms);
if (maybeDominatedSets.isNothing())
return mozilla::Nothing();
- return mozilla::Some(DominatorTree(mozilla::Move(postOrder),
- mozilla::Move(nodeToPostOrderIndex),
- mozilla::Move(doms),
- mozilla::Move(*maybeDominatedSets)));
+ return mozilla::Some(DominatorTree(std::move(postOrder),
+ std::move(nodeToPostOrderIndex),
+ std::move(doms),
+ std::move(*maybeDominatedSets)));
}
/**
* Get the root node for this dominator tree.
*/
const Node& root() const {
return postOrder[postOrder.length() - 1];
}
--- a/js/public/UbiNodePostOrder.h
+++ b/js/public/UbiNodePostOrder.h
@@ -54,32 +54,32 @@ namespace ubi {
struct PostOrder {
private:
struct OriginAndEdges {
Node origin;
EdgeVector edges;
OriginAndEdges(const Node& node, EdgeVector&& edges)
: origin(node)
- , edges(mozilla::Move(edges))
+ , edges(std::move(edges))
{ }
OriginAndEdges(const OriginAndEdges& rhs) = delete;
OriginAndEdges& operator=(const OriginAndEdges& rhs) = delete;
OriginAndEdges(OriginAndEdges&& rhs)
: origin(rhs.origin)
- , edges(mozilla::Move(rhs.edges))
+ , edges(std::move(rhs.edges))
{
MOZ_ASSERT(&rhs != this, "self-move disallowed");
}
OriginAndEdges& operator=(OriginAndEdges&& rhs) {
this->~OriginAndEdges();
- new (this) OriginAndEdges(mozilla::Move(rhs));
+ new (this) OriginAndEdges(std::move(rhs));
return *this;
}
};
using Stack = js::Vector<OriginAndEdges, 256, js::SystemAllocPolicy>;
using Set = js::HashSet<Node, js::DefaultHasher<Node>, js::SystemAllocPolicy>;
JSContext* cx;
@@ -88,28 +88,28 @@ struct PostOrder {
#ifdef DEBUG
bool traversed;
#endif
private:
MOZ_MUST_USE bool fillEdgesFromRange(EdgeVector& edges, js::UniquePtr<EdgeRange>& range) {
MOZ_ASSERT(range);
for ( ; !range->empty(); range->popFront()) {
- if (!edges.append(mozilla::Move(range->front())))
+ if (!edges.append(std::move(range->front())))
return false;
}
return true;
}
MOZ_MUST_USE bool pushForTraversing(const Node& node) {
EdgeVector edges;
auto range = node.edges(cx, /* wantNames */ false);
return range &&
fillEdgesFromRange(edges, range) &&
- stack.append(OriginAndEdges(node, mozilla::Move(edges)));
+ stack.append(OriginAndEdges(node, std::move(edges)));
}
public:
// Construct a post-order traversal object.
//
// The traversal asserts that no GC happens in its runtime during its
// lifetime via the `AutoCheckCannotGC&` parameter. We do nothing with it,
@@ -156,17 +156,17 @@ struct PostOrder {
if (edges.empty()) {
if (!onNode(origin))
return false;
stack.popBack();
continue;
}
- Edge edge = mozilla::Move(edges.back());
+ Edge edge = std::move(edges.back());
edges.popBack();
if (!onEdge(origin, edge))
return false;
auto ptr = seen.lookupForAdd(edge.referent);
// We've already seen this node, don't follow its edges.
if (ptr)
--- a/js/public/UbiNodeShortestPaths.h
+++ b/js/public/UbiNodeShortestPaths.h
@@ -32,33 +32,33 @@ struct JS_PUBLIC_API(BackEdge)
BackEdge() : predecessor_(), name_(nullptr) { }
MOZ_MUST_USE bool init(const Node& predecessor, Edge& edge) {
MOZ_ASSERT(!predecessor_);
MOZ_ASSERT(!name_);
predecessor_ = predecessor;
- name_ = mozilla::Move(edge.name);
+ name_ = std::move(edge.name);
return true;
}
BackEdge(const BackEdge&) = delete;
BackEdge& operator=(const BackEdge&) = delete;
BackEdge(BackEdge&& rhs)
: predecessor_(rhs.predecessor_)
- , name_(mozilla::Move(rhs.name_))
+ , name_(std::move(rhs.name_))
{
MOZ_ASSERT(&rhs != this);
}
BackEdge& operator=(BackEdge&& rhs) {
this->~BackEdge();
- new(this) BackEdge(Move(rhs));
+ new(this) BackEdge(std::move(rhs));
return *this;
}
Ptr clone() const;
const EdgeName& name() const { return name_; }
EdgeName& name() { return name_; }
@@ -130,32 +130,32 @@ struct JS_PUBLIC_API(ShortestPaths)
if (first) {
BackEdgeVector paths;
if (!paths.reserve(shortestPaths.maxNumPaths_))
return false;
auto cloned = back->clone();
if (!cloned)
return false;
- paths.infallibleAppend(mozilla::Move(cloned));
- if (!shortestPaths.paths_.putNew(edge.referent, mozilla::Move(paths)))
+ paths.infallibleAppend(std::move(cloned));
+ if (!shortestPaths.paths_.putNew(edge.referent, std::move(paths)))
return false;
totalPathsRecorded++;
} else {
auto ptr = shortestPaths.paths_.lookup(edge.referent);
MOZ_ASSERT(ptr,
"This isn't the first time we have seen the target node `edge.referent`. "
"We should have inserted it into shortestPaths.paths_ the first time we "
"saw it.");
if (ptr->value().length() < shortestPaths.maxNumPaths_) {
BackEdge::Ptr thisBackEdge(js_new<BackEdge>());
if (!thisBackEdge || !thisBackEdge->init(origin, edge))
return false;
- ptr->value().infallibleAppend(mozilla::Move(thisBackEdge));
+ ptr->value().infallibleAppend(std::move(thisBackEdge));
totalPathsRecorded++;
}
}
MOZ_ASSERT(totalPathsRecorded <= totalMaxPathsToRecord);
if (totalPathsRecorded == totalMaxPathsToRecord)
traversal.stop();
@@ -181,17 +181,17 @@ struct JS_PUBLIC_API(ShortestPaths)
Traversal::NodeMap backEdges_;
private:
// Private methods.
ShortestPaths(uint32_t maxNumPaths, const Node& root, NodeSet&& targets)
: maxNumPaths_(maxNumPaths)
, root_(root)
- , targets_(mozilla::Move(targets))
+ , targets_(std::move(targets))
, paths_()
, backEdges_()
{
MOZ_ASSERT(maxNumPaths_ > 0);
MOZ_ASSERT(root_);
MOZ_ASSERT(targets_.initialized());
}
@@ -202,26 +202,26 @@ struct JS_PUBLIC_API(ShortestPaths)
}
public:
// Public methods.
ShortestPaths(ShortestPaths&& rhs)
: maxNumPaths_(rhs.maxNumPaths_)
, root_(rhs.root_)
- , targets_(mozilla::Move(rhs.targets_))
- , paths_(mozilla::Move(rhs.paths_))
- , backEdges_(mozilla::Move(rhs.backEdges_))
+ , targets_(std::move(rhs.targets_))
+ , paths_(std::move(rhs.paths_))
+ , backEdges_(std::move(rhs.backEdges_))
{
MOZ_ASSERT(this != &rhs, "self-move is not allowed");
}
ShortestPaths& operator=(ShortestPaths&& rhs) {
this->~ShortestPaths();
- new (this) ShortestPaths(mozilla::Move(rhs));
+ new (this) ShortestPaths(std::move(rhs));
return *this;
}
ShortestPaths(const ShortestPaths&) = delete;
ShortestPaths& operator=(const ShortestPaths&) = delete;
/**
* Construct a new `JS::ubi::ShortestPaths`, finding up to `maxNumPaths`
@@ -244,33 +244,33 @@ struct JS_PUBLIC_API(ShortestPaths)
* responsibility to handle and report the OOM.
*/
static mozilla::Maybe<ShortestPaths>
Create(JSContext* cx, AutoCheckCannotGC& noGC, uint32_t maxNumPaths, const Node& root, NodeSet&& targets) {
MOZ_ASSERT(targets.count() > 0);
MOZ_ASSERT(maxNumPaths > 0);
size_t count = targets.count();
- ShortestPaths paths(maxNumPaths, root, mozilla::Move(targets));
+ ShortestPaths paths(maxNumPaths, root, std::move(targets));
if (!paths.paths_.init(count))
return mozilla::Nothing();
Handler handler(paths);
Traversal traversal(cx, handler, noGC);
traversal.wantNames = true;
if (!traversal.init() || !traversal.addStart(root) || !traversal.traverse())
return mozilla::Nothing();
// Take ownership of the back edges we created while traversing the
// graph so that we can follow them from `paths_` and don't
// use-after-free.
- paths.backEdges_ = mozilla::Move(traversal.visited);
+ paths.backEdges_ = std::move(traversal.visited);
MOZ_ASSERT(paths.initialized());
- return mozilla::Some(mozilla::Move(paths));
+ return mozilla::Some(std::move(paths));
}
/**
* Get a range that iterates over each target node we searched for retaining
* paths for. The returned range must not outlive the `ShortestPaths`
* instance.
*/
NodeSet::Range eachTarget() const {
--- a/js/src/builtin/ModuleObject.cpp
+++ b/js/src/builtin/ModuleObject.cpp
@@ -1135,17 +1135,17 @@ ModuleObject::createNamespace(JSContext*
Zone* zone = cx->zone();
auto bindings = zone->make_unique<IndirectBindingMap>();
if (!bindings) {
ReportOutOfMemory(cx);
return nullptr;
}
- auto ns = ModuleNamespaceObject::create(cx, self, exports, Move(bindings));
+ auto ns = ModuleNamespaceObject::create(cx, self, exports, std::move(bindings));
if (!ns)
return nullptr;
self->initReservedSlot(NamespaceSlot, ObjectValue(*ns));
return ns;
}
static bool
--- a/js/src/builtin/TestingFunctions.cpp
+++ b/js/src/builtin/TestingFunctions.cpp
@@ -1333,17 +1333,17 @@ SaveStack(JSContext* cx, unsigned argc,
return false;
}
RootedObject stack(cx);
{
Maybe<AutoRealm> ar;
if (compartmentObject)
ar.emplace(cx, compartmentObject);
- if (!JS::CaptureCurrentStack(cx, &stack, mozilla::Move(capture)))
+ if (!JS::CaptureCurrentStack(cx, &stack, std::move(capture)))
return false;
}
if (stack && !cx->compartment()->wrap(cx, &stack))
return false;
args.rval().setObjectOrNull(stack);
return true;
@@ -1368,17 +1368,17 @@ CaptureFirstSubsumedFrame(JSContext* cx,
return false;
}
JS::StackCapture capture(JS::FirstSubsumedFrame(cx, obj->realm()->principals()));
if (args.length() > 1)
capture.as<JS::FirstSubsumedFrame>().ignoreSelfHosted = JS::ToBoolean(args[1]);
JS::RootedObject capturedStack(cx);
- if (!JS::CaptureCurrentStack(cx, &capturedStack, mozilla::Move(capture)))
+ if (!JS::CaptureCurrentStack(cx, &capturedStack, std::move(capture)))
return false;
args.rval().setObjectOrNull(capturedStack);
return true;
}
static bool
CallFunctionFromNativeFrame(JSContext* cx, unsigned argc, Value* vp)
@@ -3481,26 +3481,26 @@ class BackEdge {
// The name of this edge.
EdgeName name_;
public:
BackEdge() : name_(nullptr) { }
// Construct an initialized back edge, taking ownership of |name|.
BackEdge(JS::ubi::Node predecessor, EdgeName name)
- : predecessor_(predecessor), name_(Move(name)) { }
- BackEdge(BackEdge&& rhs) : predecessor_(rhs.predecessor_), name_(Move(rhs.name_)) { }
+ : predecessor_(predecessor), name_(std::move(name)) { }
+ BackEdge(BackEdge&& rhs) : predecessor_(rhs.predecessor_), name_(std::move(rhs.name_)) { }
BackEdge& operator=(BackEdge&& rhs) {
MOZ_ASSERT(&rhs != this);
this->~BackEdge();
- new(this) BackEdge(Move(rhs));
+ new(this) BackEdge(std::move(rhs));
return *this;
}
- EdgeName forgetName() { return Move(name_); }
+ EdgeName forgetName() { return std::move(name_); }
JS::ubi::Node predecessor() const { return predecessor_; }
private:
// No copy constructor or copying assignment.
BackEdge(const BackEdge&) = delete;
BackEdge& operator=(const BackEdge&) = delete;
};
@@ -3523,17 +3523,17 @@ struct FindPathHandler {
if (!first)
return true;
// Record how we reached this node. This is the last edge on a
// shortest path to this node.
EdgeName edgeName = DuplicateString(cx, edge.name.get());
if (!edgeName)
return false;
- *backEdge = mozilla::Move(BackEdge(origin, Move(edgeName)));
+ *backEdge = std::move(BackEdge(origin, std::move(edgeName)));
// Have we reached our final target node?
if (edge.referent == target) {
// Record the path that got us here, which must be a shortest path.
if (!recordPath(traversal))
return false;
foundPath = true;
traversal.stop();
@@ -3671,17 +3671,17 @@ FindPath(JSContext* cx, unsigned argc, V
RootedValue wrapped(cx, nodes[i]);
if (!cx->compartment()->wrap(cx, &wrapped))
return false;
if (!JS_DefineProperty(cx, obj, "node", wrapped, JSPROP_ENUMERATE))
return false;
- heaptools::EdgeName edgeName = Move(edges[i]);
+ heaptools::EdgeName edgeName = std::move(edges[i]);
RootedString edgeStr(cx, NewString<CanGC>(cx, edgeName.get(), js_strlen(edgeName.get())));
if (!edgeStr)
return false;
mozilla::Unused << edgeName.release(); // edgeStr acquired ownership
if (!JS_DefineProperty(cx, obj, "edge", edgeStr, JSPROP_ENUMERATE))
return false;
@@ -3765,17 +3765,17 @@ ShortestPaths(JSContext* cx, unsigned ar
if (!targets.put(node)) {
ReportOutOfMemory(cx);
return false;
}
}
JS::ubi::Node root(args[0]);
auto maybeShortestPaths = JS::ubi::ShortestPaths::Create(cx, noGC, maxNumPaths,
- root, mozilla::Move(targets));
+ root, std::move(targets));
if (maybeShortestPaths.isNothing()) {
ReportOutOfMemory(cx);
return false;
}
auto& shortestPaths = *maybeShortestPaths;
for (size_t i = 0; i < length; i++) {
if (!values.append(GCVector<GCVector<Value>>(cx)) ||
@@ -3788,24 +3788,24 @@ ShortestPaths(JSContext* cx, unsigned ar
JS::ubi::Node target(val);
bool ok = shortestPaths.forEachPath(target, [&](JS::ubi::Path& path) {
Rooted<GCVector<Value>> pathVals(cx, GCVector<Value>(cx));
Vector<JS::ubi::EdgeName> pathNames(cx);
for (auto& part : path) {
if (!pathVals.append(part->predecessor().exposeToJS()) ||
- !pathNames.append(mozilla::Move(part->name())))
+ !pathNames.append(std::move(part->name())))
{
return false;
}
}
- return values.back().append(mozilla::Move(pathVals.get())) &&
- names.back().append(mozilla::Move(pathNames));
+ return values.back().append(std::move(pathVals.get())) &&
+ names.back().append(std::move(pathNames));
});
if (!ok)
return false;
}
}
MOZ_ASSERT(values.length() == names.length());
--- a/js/src/builtin/TypedObject.cpp
+++ b/js/src/builtin/TypedObject.cpp
@@ -2144,17 +2144,17 @@ ArrayBufferObject*
InlineTransparentTypedObject::getOrCreateBuffer(JSContext* cx)
{
ObjectRealm& realm = ObjectRealm::get(this);
if (!realm.lazyArrayBuffers) {
auto table = cx->make_unique<ObjectWeakMap>(cx);
if (!table || !table->init())
return nullptr;
- realm.lazyArrayBuffers = Move(table);
+ realm.lazyArrayBuffers = std::move(table);
}
ObjectWeakMap* table = realm.lazyArrayBuffers.get();
JSObject* obj = table->lookup(this);
if (obj)
return &obj->as<ArrayBufferObject>();
--- a/js/src/ctypes/CTypes.cpp
+++ b/js/src/ctypes/CTypes.cpp
@@ -5753,17 +5753,17 @@ ArrayType::BuildFFIType(JSContext* cx, J
JS_ReportAllocationOverflow(cx);
return nullptr;
}
for (size_t i = 0; i < length; ++i)
ffiType->elements[i] = ffiBaseType;
ffiType->elements[length] = nullptr;
- return Move(ffiType);
+ return std::move(ffiType);
}
bool
ArrayType::IsArrayType(HandleValue v)
{
if (!v.isObject())
return false;
JSObject* obj = &v.toObject();
@@ -6218,17 +6218,17 @@ StructType::DefineInternal(JSContext* cx
RootedValue sizeVal(cx);
if (!SizeTojsval(cx, structSize, &sizeVal)) {
SizeOverflow(cx, "struct size", "double");
return false;
}
// Move the field hash to the heap and store it in the typeObj.
- FieldInfoHash *heapHash = cx->new_<FieldInfoHash>(mozilla::Move(fields.get()));
+ FieldInfoHash *heapHash = cx->new_<FieldInfoHash>(std::move(fields.get()));
if (!heapHash) {
JS_ReportOutOfMemory(cx);
return false;
}
MOZ_ASSERT(heapHash->initialized());
JS_SetReservedSlot(typeObj, SLOT_FIELDINFO, PrivateValue(heapHash));
JS_SetReservedSlot(typeObj, SLOT_SIZE, sizeVal);
@@ -6301,17 +6301,17 @@ StructType::BuildFFIType(JSContext* cx,
// Fill in the ffi_type's size and align fields. This makes libffi treat the
// type as initialized; it will not recompute the values. (We assume
// everything agrees; if it doesn't, we really want to know about it, which
// is the purpose of the above debug-only check.)
ffiType->size = structSize;
ffiType->alignment = structAlign;
#endif
- return Move(ffiType);
+ return std::move(ffiType);
}
bool
StructType::Define(JSContext* cx, unsigned argc, Value* vp)
{
CallArgs args = CallArgsFromVp(argc, vp);
RootedObject obj(cx, GetThisObject(cx, args, "StructType.prototype.define"));
if (!obj)
--- a/js/src/ctypes/CTypes.h
+++ b/js/src/ctypes/CTypes.h
@@ -93,17 +93,17 @@ class StringBuilder {
// be checked for errors before calling this, however.
Vector<CharT, N, SystemAllocPolicy>&& finish() {
MOZ_ASSERT(!errored);
MOZ_ASSERT(!finished);
MOZ_ASSERT(checked);
#ifdef DEBUG
finished = true;
#endif
- return mozilla::Move(v);
+ return std::move(v);
}
};
// Note that these strings do not have any inline storage, because we use move
// constructors to pass the data around and inline storage would necessitate
// copying.
typedef StringBuilder<char16_t, 0> AutoString;
typedef StringBuilder<char, 0> AutoCString;
--- a/js/src/ds/Fifo.h
+++ b/js/src/ds/Fifo.h
@@ -56,24 +56,24 @@ class Fifo
public:
explicit Fifo(AllocPolicy alloc = AllocPolicy())
: front_(alloc)
, rear_(alloc)
{ }
Fifo(Fifo&& rhs)
- : front_(mozilla::Move(rhs.front_))
- , rear_(mozilla::Move(rhs.rear_))
+ : front_(std::move(rhs.front_))
+ , rear_(std::move(rhs.rear_))
{ }
Fifo& operator=(Fifo&& rhs) {
MOZ_ASSERT(&rhs != this, "self-move disallowed");
this->~Fifo();
- new (this) Fifo(mozilla::Move(rhs));
+ new (this) Fifo(std::move(rhs));
return *this;
}
Fifo(const Fifo&) = delete;
Fifo& operator=(const Fifo&) = delete;
size_t length() const {
MOZ_ASSERT_IF(rear_.length() > 0, front_.length() > 0); // Invariant 4.
--- a/js/src/ds/InlineTable.h
+++ b/js/src/ds/InlineTable.h
@@ -440,17 +440,17 @@ class InlineMap
template <typename KeyInput, typename ValueInput>
void update(KeyInput&& key, ValueInput&& value) {
this->key = mozilla::Forward<KeyInput>(key);
this->value = mozilla::Forward<ValueInput>(value);
}
MOZ_MUST_USE bool moveTo(Map& map) {
- return map.putNew(mozilla::Move(key), mozilla::Move(value));
+ return map.putNew(std::move(key), std::move(value));
}
};
class Entry
{
using MapEntry = typename Map::Entry;
MapEntry* mapEntry_;
@@ -578,17 +578,17 @@ class InlineSet
T key;
template <typename TInput>
void update(TInput&& key) {
this->key = mozilla::Forward<TInput>(key);
}
MOZ_MUST_USE bool moveTo(Set& set) {
- return set.putNew(mozilla::Move(key));
+ return set.putNew(std::move(key));
}
};
class Entry
{
using SetEntry = typename Set::Entry;
SetEntry* setEntry_;
--- a/js/src/ds/LifoAlloc.cpp
+++ b/js/src/ds/LifoAlloc.cpp
@@ -46,21 +46,21 @@ BumpChunk::canAlloc(size_t n)
} // namespace detail
} // namespace js
void
LifoAlloc::freeAll()
{
while (!chunks_.empty()) {
- BumpChunk bc = mozilla::Move(chunks_.popFirst());
+ BumpChunk bc = std::move(chunks_.popFirst());
decrementCurSize(bc->computedSizeOfIncludingThis());
}
while (!unused_.empty()) {
- BumpChunk bc = mozilla::Move(unused_.popFirst());
+ BumpChunk bc = std::move(unused_.popFirst());
decrementCurSize(bc->computedSizeOfIncludingThis());
}
// Nb: maintaining curSize_ correctly isn't easy. Fortunately, this is an
// excellent sanity check.
MOZ_ASSERT(curSize_ == 0);
}
@@ -100,60 +100,60 @@ LifoAlloc::newChunkWithCapacity(size_t n
bool
LifoAlloc::getOrCreateChunk(size_t n)
{
// Look for existing unused BumpChunks to satisfy the request, and pick the
// first one which is large enough, and move it into the list of used
// chunks.
if (!unused_.empty()) {
if (unused_.begin()->canAlloc(n)) {
- chunks_.append(mozilla::Move(unused_.popFirst()));
+ chunks_.append(std::move(unused_.popFirst()));
return true;
}
BumpChunkList::Iterator e(unused_.end());
for (BumpChunkList::Iterator i(unused_.begin()); i->next() != e.get(); ++i) {
detail::BumpChunk* elem = i->next();
MOZ_ASSERT(elem->empty());
if (elem->canAlloc(n)) {
- BumpChunkList temp = mozilla::Move(unused_.splitAfter(i.get()));
- chunks_.append(mozilla::Move(temp.popFirst()));
- unused_.appendAll(mozilla::Move(temp));
+ BumpChunkList temp = std::move(unused_.splitAfter(i.get()));
+ chunks_.append(std::move(temp.popFirst()));
+ unused_.appendAll(std::move(temp));
return true;
}
}
}
// Allocate a new BumpChunk with enough space for the next allocation.
BumpChunk newChunk = newChunkWithCapacity(n);
if (!newChunk)
return false;
size_t size = newChunk->computedSizeOfIncludingThis();
- chunks_.append(mozilla::Move(newChunk));
+ chunks_.append(std::move(newChunk));
incrementCurSize(size);
return true;
}
void
LifoAlloc::transferFrom(LifoAlloc* other)
{
MOZ_ASSERT(!markCount);
MOZ_ASSERT(!other->markCount);
incrementCurSize(other->curSize_);
- appendUnused(mozilla::Move(other->unused_));
- appendUsed(mozilla::Move(other->chunks_));
+ appendUnused(std::move(other->unused_));
+ appendUsed(std::move(other->chunks_));
other->curSize_ = 0;
}
void
LifoAlloc::transferUnusedFrom(LifoAlloc* other)
{
MOZ_ASSERT(!markCount);
size_t size = 0;
for (detail::BumpChunk& bc : other->unused_)
size += bc.computedSizeOfIncludingThis();
- appendUnused(mozilla::Move(other->unused_));
+ appendUnused(std::move(other->unused_));
incrementCurSize(size);
other->decrementCurSize(size);
}
--- a/js/src/ds/LifoAlloc.h
+++ b/js/src/ds/LifoAlloc.h
@@ -73,32 +73,32 @@ class SingleLinkedList
public:
SingleLinkedList()
: head_(nullptr), last_(nullptr)
{
assertInvariants();
}
SingleLinkedList(SingleLinkedList&& other)
- : head_(mozilla::Move(other.head_)), last_(other.last_)
+ : head_(std::move(other.head_)), last_(other.last_)
{
other.last_ = nullptr;
assertInvariants();
other.assertInvariants();
}
~SingleLinkedList() {
MOZ_ASSERT(!head_);
MOZ_ASSERT(!last_);
}
// Move the elements of the |other| list in the current one, and implicitly
// remove all the elements of the current list.
SingleLinkedList& operator=(SingleLinkedList&& other) {
- head_ = mozilla::Move(other.head_);
+ head_ = std::move(other.head_);
last_ = other.last_;
other.last_ = nullptr;
assertInvariants();
other.assertInvariants();
return *this;
}
bool empty() const { return !last_; }
@@ -137,59 +137,59 @@ class SingleLinkedList
// back goes in the newly create linked list.
//
// This is used for example to extract one element from a list. (see
// LifoAlloc::getOrCreateChunk)
SingleLinkedList splitAfter(T* newLast) {
MOZ_ASSERT(newLast);
SingleLinkedList result;
if (newLast->next_) {
- result.head_ = mozilla::Move(newLast->next_);
+ result.head_ = std::move(newLast->next_);
result.last_ = last_;
last_ = newLast;
}
assertInvariants();
result.assertInvariants();
return result;
}
void pushFront(UniquePtr<T>&& elem) {
if (!last_)
last_ = elem.get();
- elem->next_ = mozilla::Move(head_);
- head_ = mozilla::Move(elem);
+ elem->next_ = std::move(head_);
+ head_ = std::move(elem);
assertInvariants();
}
void append(UniquePtr<T>&& elem) {
if (last_) {
- last_->next_ = mozilla::Move(elem);
+ last_->next_ = std::move(elem);
last_ = last_->next_.get();
} else {
- head_ = mozilla::Move(elem);
+ head_ = std::move(elem);
last_ = head_.get();
}
assertInvariants();
}
void appendAll(SingleLinkedList&& list) {
if (list.empty())
return;
if (last_)
- last_->next_ = mozilla::Move(list.head_);
+ last_->next_ = std::move(list.head_);
else
- head_ = mozilla::Move(list.head_);
+ head_ = std::move(list.head_);
last_ = list.last_;
list.last_ = nullptr;
assertInvariants();
list.assertInvariants();
}
UniquePtr<T> popFirst() {
MOZ_ASSERT(head_);
- UniquePtr<T> result = mozilla::Move(head_);
- head_ = mozilla::Move(result->next_);
+ UniquePtr<T> result = std::move(head_);
+ head_ = std::move(result->next_);
if (!head_)
last_ = nullptr;
assertInvariants();
return result;
}
};
static const size_t LIFO_ALLOC_ALIGN = 8;
@@ -495,23 +495,23 @@ class LifoAlloc
}
// Append unused chunks to the end of this LifoAlloc.
void appendUnused(BumpChunkList&& otherUnused) {
#ifdef DEBUG
for (detail::BumpChunk& bc: otherUnused)
MOZ_ASSERT(bc.empty());
#endif
- unused_.appendAll(mozilla::Move(otherUnused));
+ unused_.appendAll(std::move(otherUnused));
}
// Append used chunks to the end of this LifoAlloc. We act as if all the
// chunks in |this| are used, even if they're not, so memory may be wasted.
void appendUsed(BumpChunkList&& otherChunks) {
- chunks_.appendAll(mozilla::Move(otherChunks));
+ chunks_.appendAll(std::move(otherChunks));
}
// Track the amount of space allocated in used and unused chunks.
void incrementCurSize(size_t size) {
curSize_ += size;
if (curSize_ > peakSize_)
peakSize_ = curSize_;
}
@@ -547,18 +547,18 @@ class LifoAlloc
// Steal allocated chunks from |other|.
void steal(LifoAlloc* other) {
MOZ_ASSERT(!other->markCount);
MOZ_ASSERT(chunks_.empty());
// Copy everything from |other| to |this| except for |peakSize_|, which
// requires some care.
- chunks_ = mozilla::Move(other->chunks_);
- unused_ = mozilla::Move(other->unused_);
+ chunks_ = std::move(other->chunks_);
+ unused_ = std::move(other->unused_);
markCount = other->markCount;
defaultChunkSize_ = other->defaultChunkSize_;
curSize_ = other->curSize_;
peakSize_ = Max(peakSize_, other->peakSize_);
#if defined(DEBUG) || defined(JS_OOM_BREAKPOINT)
fallibleScope_ = other->fallibleScope_;
#endif
@@ -636,17 +636,17 @@ class LifoAlloc
if (total >= n)
return true;
}
BumpChunk newChunk = newChunkWithCapacity(n);
if (!newChunk)
return false;
size_t size = newChunk->computedSizeOfIncludingThis();
- unused_.pushFront(mozilla::Move(newChunk));
+ unused_.pushFront(std::move(newChunk));
incrementCurSize(size);
return true;
}
MOZ_ALWAYS_INLINE
void setAsInfallibleByDefault() {
#if defined(DEBUG) || defined(JS_OOM_BREAKPOINT)
fallibleScope_ = false;
@@ -704,35 +704,35 @@ class LifoAlloc
}
void release(Mark mark) {
markCount--;
// Move the blocks which are after the mark to the set of unused chunks.
BumpChunkList released;
if (!mark.markedChunk())
- released = mozilla::Move(chunks_);
+ released = std::move(chunks_);
else
- released = mozilla::Move(chunks_.splitAfter(mark.markedChunk()));
+ released = std::move(chunks_.splitAfter(mark.markedChunk()));
// Release the content of all the blocks which are after the marks.
for (detail::BumpChunk& bc : released)
bc.release();
- unused_.appendAll(mozilla::Move(released));
+ unused_.appendAll(std::move(released));
// Release everything which follows the mark in the last chunk.
if (!chunks_.empty())
chunks_.last()->release(mark);
}
void releaseAll() {
MOZ_ASSERT(!markCount);
for (detail::BumpChunk& bc : chunks_)
bc.release();
- unused_.appendAll(mozilla::Move(chunks_));
+ unused_.appendAll(std::move(chunks_));
}
// Get the total "used" (occupied bytes) count for the arena chunks.
size_t used() const {
size_t accum = 0;
for (const detail::BumpChunk& chunk : chunks_)
accum += chunk.used();
return accum;
--- a/js/src/ds/OrderedHashTable.h
+++ b/js/src/ds/OrderedHashTable.h
@@ -60,17 +60,17 @@ class OrderedHashTable
typedef typename Ops::Lookup Lookup;
struct Data
{
T element;
Data* chain;
Data(const T& e, Data* c) : element(e), chain(c) {}
- Data(T&& e, Data* c) : element(Move(e)), chain(c) {}
+ Data(T&& e, Data* c) : element(std::move(e)), chain(c) {}
};
class Range;
friend class Range;
private:
Data** hashTable; // hash table (has hashBuckets() elements)
Data* data; // data vector, an array of Data objects
@@ -659,17 +659,17 @@ class OrderedHashTable
for (uint32_t i = 0, N = hashBuckets(); i < N; i++)
hashTable[i] = nullptr;
Data* wp = data;
Data* end = data + dataLength;
for (Data* rp = data; rp != end; rp++) {
if (!Ops::isEmpty(Ops::getKey(rp->element))) {
HashNumber h = prepareHash(Ops::getKey(rp->element)) >> hashShift;
if (rp != wp)
- wp->element = Move(rp->element);
+ wp->element = std::move(rp->element);
wp->chain = hashTable[h];
hashTable[h] = wp;
wp++;
}
}
MOZ_ASSERT(wp == data + liveCount);
while (wp != end)
@@ -708,17 +708,17 @@ class OrderedHashTable
return false;
}
Data* wp = newData;
Data* end = data + dataLength;
for (Data* p = data; p != end; p++) {
if (!Ops::isEmpty(Ops::getKey(p->element))) {
HashNumber h = prepareHash(Ops::getKey(p->element)) >> newHashShift;
- new (wp) Data(Move(p->element), newHashTable[h]);
+ new (wp) Data(std::move(p->element), newHashTable[h]);
newHashTable[h] = wp;
wp++;
}
}
MOZ_ASSERT(wp == newData + liveCount);
alloc.free_(hashTable);
freeData(data, dataLength);
@@ -750,25 +750,25 @@ class OrderedHashMap
template <class, class, class> friend class detail::OrderedHashTable;
void operator=(const Entry& rhs) {
const_cast<Key&>(key) = rhs.key;
value = rhs.value;
}
void operator=(Entry&& rhs) {
MOZ_ASSERT(this != &rhs, "self-move assignment is prohibited");
- const_cast<Key&>(key) = Move(rhs.key);
- value = Move(rhs.value);
+ const_cast<Key&>(key) = std::move(rhs.key);
+ value = std::move(rhs.value);
}
public:
Entry() : key(), value() {}
template <typename V>
Entry(const Key& k, V&& v) : key(k), value(Forward<V>(v)) {}
- Entry(Entry&& rhs) : key(Move(rhs.key)), value(Move(rhs.value)) {}
+ Entry(Entry&& rhs) : key(std::move(rhs.key)), value(std::move(rhs.value)) {}
const Key key;
Value value;
static size_t offsetOfKey() {
return offsetof(Entry, key);
}
static size_t offsetOfValue() {
--- a/js/src/ds/TraceableFifo.h
+++ b/js/src/ds/TraceableFifo.h
@@ -33,18 +33,18 @@ template <typename T,
typename AllocPolicy = TempAllocPolicy>
class TraceableFifo : public js::Fifo<T, MinInlineCapacity, AllocPolicy>
{
using Base = js::Fifo<T, MinInlineCapacity, AllocPolicy>;
public:
explicit TraceableFifo(AllocPolicy alloc = AllocPolicy()) : Base(alloc) {}
- TraceableFifo(TraceableFifo&& rhs) : Base(mozilla::Move(rhs)) { }
- TraceableFifo& operator=(TraceableFifo&& rhs) { return Base::operator=(mozilla::Move(rhs)); }
+ TraceableFifo(TraceableFifo&& rhs) : Base(std::move(rhs)) { }
+ TraceableFifo& operator=(TraceableFifo&& rhs) { return Base::operator=(std::move(rhs)); }
TraceableFifo(const TraceableFifo&) = delete;
TraceableFifo& operator=(const TraceableFifo&) = delete;
void trace(JSTracer* trc) {
for (size_t i = 0; i < this->front_.length(); ++i)
JS::GCPolicy<T>::trace(trc, &this->front_[i], "fifo element");
for (size_t i = 0; i < this->rear_.length(); ++i)
--- a/js/src/frontend/BinSource.cpp
+++ b/js/src/frontend/BinSource.cpp
@@ -451,48 +451,48 @@ BinASTParser<Tok>::poison()
template<typename Tok> void
BinASTParser<Tok>::reportErrorNoOffsetVA(unsigned errorNumber, va_list args)
{
ErrorMetadata metadata;
metadata.filename = getFilename();
metadata.lineNumber = 0;
metadata.columnNumber = offset();
metadata.isMuted = options().mutedErrors();
- ReportCompileError(cx_, Move(metadata), nullptr, JSREPORT_ERROR, errorNumber, args);
+ ReportCompileError(cx_, std::move(metadata), nullptr, JSREPORT_ERROR, errorNumber, args);
}
template<typename Tok> void
BinASTParser<Tok>::errorAtVA(uint32_t offset, unsigned errorNumber, va_list* args)
{
ErrorMetadata metadata;
metadata.filename = getFilename();
metadata.lineNumber = 0;
metadata.columnNumber = offset;
metadata.isMuted = options().mutedErrors();
- ReportCompileError(cx_, Move(metadata), nullptr, JSREPORT_ERROR, errorNumber, *args);
+ ReportCompileError(cx_, std::move(metadata), nullptr, JSREPORT_ERROR, errorNumber, *args);
}
template<typename Tok> bool
BinASTParser<Tok>::reportExtraWarningErrorNumberVA(UniquePtr<JSErrorNotes> notes, uint32_t offset, unsigned errorNumber, va_list* args)
{
if (!options().extraWarningsOption)
return true;
ErrorMetadata metadata;
metadata.filename = getFilename();
metadata.lineNumber = 0;
metadata.columnNumber = offset;
metadata.isMuted = options().mutedErrors();
if (options().werrorOption) {
- ReportCompileError(cx_, Move(metadata), Move(notes), JSREPORT_STRICT, errorNumber, *args);
+ ReportCompileError(cx_, std::move(metadata), std::move(notes), JSREPORT_STRICT, errorNumber, *args);
return false;
}
- return ReportCompileWarning(cx_, Move(metadata), Move(notes), JSREPORT_STRICT | JSREPORT_WARNING, errorNumber, *args);
+ return ReportCompileWarning(cx_, std::move(metadata), std::move(notes), JSREPORT_STRICT | JSREPORT_WARNING, errorNumber, *args);
}
bool
BinASTParserBase::hasUsedName(HandlePropertyName name)
{
if (UsedNamePtr p = usedNames_.lookup(name))
return p->value().isUsedInScript(parseContext_->scriptId());
--- a/js/src/frontend/BinTokenReaderMultipart.cpp
+++ b/js/src/frontend/BinTokenReaderMultipart.cpp
@@ -139,17 +139,17 @@ BinTokenReaderMultipart::readHeader()
BINJS_TRY_VAR(atom, Atomize(cx_, (const char*)current_, byteLen));
}
// Populate `atomsTable_`: i => atom.
atomsTable_.infallibleAppend(atom); // We have reserved before entering the loop.
// Populate `slicesTable_`: i => slice
Chars slice((const char*)current_, byteLen);
- slicesTable_.infallibleAppend(Move(slice)); // We have reserved before entering the loop.
+ slicesTable_.infallibleAppend(std::move(slice)); // We have reserved before entering the loop.
current_ += byteLen;
}
if (posBeforeStrings + stringsByteLen != current_)
return raiseError("The length of the strings table didn't match its contents.");
// Start reading AST.
--- a/js/src/frontend/EitherParser.h
+++ b/js/src/frontend/EitherParser.h
@@ -149,24 +149,24 @@ class EitherParser : public BCEParserHan
return parser.match(detail::ErrorReporterMatcher());
}
const ErrorReporter& errorReporter() const final {
return parser.match(detail::ErrorReporterMatcher());
}
const JS::ReadOnlyCompileOptions& options() const final {
InvokeMemberFunction<detail::GetParser, detail::ParserOptions> optionsMatcher;
- return parser.match(mozilla::Move(optionsMatcher));
+ return parser.match(std::move(optionsMatcher));
}
ObjectBox* newObjectBox(JSObject* obj) final {
InvokeMemberFunction<detail::GetParser, detail::ParserNewObjectBox,
JSObject*>
matcher { obj };
- return parser.match(mozilla::Move(matcher));
+ return parser.match(std::move(matcher));
}
};
} /* namespace frontend */
} /* namespace js */
#endif /* frontend_EitherParser_h */
--- a/js/src/frontend/ParseContext.h
+++ b/js/src/frontend/ParseContext.h
@@ -69,17 +69,17 @@ class UsedNameTracker
void resetToScope(uint32_t scriptId, uint32_t scopeId);
public:
explicit UsedNameInfo(JSContext* cx)
: uses_(cx)
{ }
UsedNameInfo(UsedNameInfo&& other)
- : uses_(mozilla::Move(other.uses_))
+ : uses_(std::move(other.uses_))
{ }
bool noteUsedInScope(uint32_t scriptId, uint32_t scopeId) {
if (uses_.empty() || uses_.back().scopeId < scopeId)
return uses_.append(Use { scriptId, scopeId });
return true;
}
--- a/js/src/frontend/Parser.cpp
+++ b/js/src/frontend/Parser.cpp
@@ -420,17 +420,17 @@ UsedNameTracker::noteUse(JSContext* cx,
{
if (UsedNameMap::AddPtr p = map_.lookupForAdd(name)) {
if (!p->value().noteUsedInScope(scriptId, scopeId))
return false;
} else {
UsedNameInfo info(cx);
if (!info.noteUsedInScope(scriptId, scopeId))
return false;
- if (!map_.add(p, name, Move(info)))
+ if (!map_.add(p, name, std::move(info)))
return false;
}
return true;
}
void
UsedNameTracker::UsedNameInfo::resetToScope(uint32_t scriptId, uint32_t scopeId)
@@ -616,97 +616,97 @@ template <class ParseHandler, typename C
void
GeneralParser<ParseHandler, CharT>::error(unsigned errorNumber, ...)
{
va_list args;
va_start(args, errorNumber);
ErrorMetadata metadata;
if (tokenStream.computeErrorMetadata(&metadata, pos().begin))
- ReportCompileError(context, Move(metadata), nullptr, JSREPORT_ERROR, errorNumber, args);
+ ReportCompileError(context, std::move(metadata), nullptr, JSREPORT_ERROR, errorNumber, args);
va_end(args);
}
template <class ParseHandler, typename CharT>
void
GeneralParser<ParseHandler, CharT>::errorWithNotes(UniquePtr<JSErrorNotes> notes,
unsigned errorNumber, ...)
{
va_list args;
va_start(args, errorNumber);
ErrorMetadata metadata;
if (tokenStream.computeErrorMetadata(&metadata, pos().begin)) {
- ReportCompileError(context, Move(metadata), Move(notes), JSREPORT_ERROR, errorNumber,
+ ReportCompileError(context, std::move(metadata), std::move(notes), JSREPORT_ERROR, errorNumber,
args);
}
va_end(args);
}
template <class ParseHandler, typename CharT>
void
GeneralParser<ParseHandler, CharT>::errorAt(uint32_t offset, unsigned errorNumber, ...)
{
va_list args;
va_start(args, errorNumber);
ErrorMetadata metadata;
if (tokenStream.computeErrorMetadata(&metadata, offset))
- ReportCompileError(context, Move(metadata), nullptr, JSREPORT_ERROR, errorNumber, args);
+ ReportCompileError(context, std::move(metadata), nullptr, JSREPORT_ERROR, errorNumber, args);
va_end(args);
}
template <class ParseHandler, typename CharT>
void
GeneralParser<ParseHandler, CharT>::errorWithNotesAt(UniquePtr<JSErrorNotes> notes,
uint32_t offset, unsigned errorNumber, ...)
{
va_list args;
va_start(args, errorNumber);
ErrorMetadata metadata;
if (tokenStream.computeErrorMetadata(&metadata, offset)) {
- ReportCompileError(context, Move(metadata), Move(notes), JSREPORT_ERROR, errorNumber,
+ ReportCompileError(context, std::move(metadata), std::move(notes), JSREPORT_ERROR, errorNumber,
args);
}
va_end(args);
}
template <class ParseHandler, typename CharT>
bool
GeneralParser<ParseHandler, CharT>::warning(unsigned errorNumber, ...)
{
va_list args;
va_start(args, errorNumber);
ErrorMetadata metadata;
bool result =
tokenStream.computeErrorMetadata(&metadata, pos().begin) &&
- anyChars.compileWarning(Move(metadata), nullptr, JSREPORT_WARNING, errorNumber, args);
+ anyChars.compileWarning(std::move(metadata), nullptr, JSREPORT_WARNING, errorNumber, args);
va_end(args);
return result;
}
template <class ParseHandler, typename CharT>
bool
GeneralParser<ParseHandler, CharT>::warningAt(uint32_t offset, unsigned errorNumber, ...)
{
va_list args;
va_start(args, errorNumber);
ErrorMetadata metadata;
bool result = tokenStream.computeErrorMetadata(&metadata, offset);
if (result) {
result =
- anyChars.compileWarning(Move(metadata), nullptr, JSREPORT_WARNING, errorNumber, args);
+ anyChars.compileWarning(std::move(metadata), nullptr, JSREPORT_WARNING, errorNumber, args);
}
va_end(args);
return result;
}
template <class ParseHandler, typename CharT>
bool
@@ -771,32 +771,32 @@ ParserBase::warningNoOffset(unsigned err
{
va_list args;
va_start(args, errorNumber);
ErrorMetadata metadata;
anyChars.computeErrorMetadataNoOffset(&metadata);
bool result =
- anyChars.compileWarning(Move(metadata), nullptr, JSREPORT_WARNING, errorNumber, args);
+ anyChars.compileWarning(std::move(metadata), nullptr, JSREPORT_WARNING, errorNumber, args);
va_end(args);
return result;
}
void
ParserBase::errorNoOffset(unsigned errorNumber, ...)
{
va_list args;
va_start(args, errorNumber);
ErrorMetadata metadata;
anyChars.computeErrorMetadataNoOffset(&metadata);
- ReportCompileError(context, Move(metadata), nullptr, JSREPORT_ERROR, errorNumber, args);
+ ReportCompileError(context, std::move(metadata), nullptr, JSREPORT_ERROR, errorNumber, args);
va_end(args);
}
ParserBase::ParserBase(JSContext* cx, LifoAlloc& alloc,
const ReadOnlyCompileOptions& options,
bool foldConstants,
UsedNameTracker& usedNames,
@@ -1126,17 +1126,17 @@ GeneralParser<ParseHandler, CharT>::repo
if (!notes->addNoteASCII(pc->sc()->context,
getFilename(), line, column,
GetErrorMessage, nullptr,
noteNumber, lineNumber, columnNumber))
{
return;
}
- errorWithNotes(Move(notes), errorNumber);
+ errorWithNotes(std::move(notes), errorNumber);
}
template <class ParseHandler, typename CharT>
void
GeneralParser<ParseHandler, CharT>::reportRedeclaration(HandlePropertyName name,
DeclarationKind prevKind,
TokenPos pos, uint32_t prevPos)
{
@@ -1168,17 +1168,17 @@ GeneralParser<ParseHandler, CharT>::repo
getFilename(), line, column,
GetErrorMessage, nullptr,
JSMSG_REDECLARED_PREV,
lineNumber, columnNumber))
{
return;
}
- errorWithNotesAt(Move(notes), pos.begin, JSMSG_REDECLARED_VAR,
+ errorWithNotesAt(std::move(notes), pos.begin, JSMSG_REDECLARED_VAR,
DeclarationKindString(prevKind), bytes.ptr());
}
// notePositionalFormalParameter is called for both the arguments of a regular
// function definition and the arguments specified by the Function
// constructor.
//
// The 'disallowDuplicateParams' bool indicates whether the use of another
--- a/js/src/frontend/TokenStream.cpp
+++ b/js/src/frontend/TokenStream.cpp
@@ -708,36 +708,36 @@ TokenStreamSpecific<CharT, AnyCharsAcces
if (!strictMode && !anyChars.options().extraWarningsOption)
return true;
ErrorMetadata metadata;
if (!computeErrorMetadata(&metadata, offset))
return false;
if (strictMode) {
- ReportCompileError(anyChars.cx, Move(metadata), Move(notes), JSREPORT_ERROR, errorNumber,
+ ReportCompileError(anyChars.cx, std::move(metadata), std::move(notes), JSREPORT_ERROR, errorNumber,
*args);
return false;
}
- return anyChars.compileWarning(Move(metadata), Move(notes), JSREPORT_WARNING | JSREPORT_STRICT,
+ return anyChars.compileWarning(std::move(metadata), std::move(notes), JSREPORT_WARNING | JSREPORT_STRICT,
errorNumber, *args);
}
bool
TokenStreamAnyChars::compileWarning(ErrorMetadata&& metadata, UniquePtr<JSErrorNotes> notes,
unsigned flags, unsigned errorNumber, va_list args)
{
if (options().werrorOption) {
flags &= ~JSREPORT_WARNING;
- ReportCompileError(cx, Move(metadata), Move(notes), flags, errorNumber, args);
+ ReportCompileError(cx, std::move(metadata), std::move(notes), flags, errorNumber, args);
return false;
}
- return ReportCompileWarning(cx, Move(metadata), Move(notes), flags, errorNumber, args);
+ return ReportCompileWarning(cx, std::move(metadata), std::move(notes), flags, errorNumber, args);
}
void
TokenStreamAnyChars::computeErrorMetadataNoOffset(ErrorMetadata* err)
{
err->isMuted = mutedErrors;
err->filename = filename_;
err->lineNumber = 0;
@@ -890,17 +890,17 @@ void
TokenStreamSpecific<CharT, AnyCharsAccess>::reportError(unsigned errorNumber, ...)
{
va_list args;
va_start(args, errorNumber);
TokenStreamAnyChars& anyChars = anyCharsAccess();
ErrorMetadata metadata;
if (computeErrorMetadata(&metadata, anyChars.currentToken().pos.begin)) {
- ReportCompileError(anyChars.cx, Move(metadata), nullptr, JSREPORT_ERROR, errorNumber,
+ ReportCompileError(anyChars.cx, std::move(metadata), nullptr, JSREPORT_ERROR, errorNumber,
args);
}
va_end(args);
}
void
TokenStreamAnyChars::reportErrorNoOffset(unsigned errorNumber, ...)
@@ -914,30 +914,30 @@ TokenStreamAnyChars::reportErrorNoOffset
}
void
TokenStreamAnyChars::reportErrorNoOffsetVA(unsigned errorNumber, va_list args)
{
ErrorMetadata metadata;
computeErrorMetadataNoOffset(&metadata);
- ReportCompileError(cx, Move(metadata), nullptr, JSREPORT_ERROR, errorNumber, args);
+ ReportCompileError(cx, std::move(metadata), nullptr, JSREPORT_ERROR, errorNumber, args);
}
template<typename CharT, class AnyCharsAccess>
bool
TokenStreamSpecific<CharT, AnyCharsAccess>::warning(unsigned errorNumber, ...)
{
va_list args;
va_start(args, errorNumber);
ErrorMetadata metadata;
bool result =
computeErrorMetadata(&metadata, anyCharsAccess().currentToken().pos.begin) &&
- anyCharsAccess().compileWarning(Move(metadata), nullptr, JSREPORT_WARNING, errorNumber,
+ anyCharsAccess().compileWarning(std::move(metadata), nullptr, JSREPORT_WARNING, errorNumber,
args);
va_end(args);
return result;
}
template<typename CharT, class AnyCharsAccess>
bool
@@ -949,45 +949,45 @@ TokenStreamSpecific<CharT, AnyCharsAcces
TokenStreamAnyChars& anyChars = anyCharsAccess();
if (!anyChars.options().extraWarningsOption)
return true;
ErrorMetadata metadata;
if (!computeErrorMetadata(&metadata, offset))
return false;
- return anyChars.compileWarning(Move(metadata), Move(notes), JSREPORT_STRICT | JSREPORT_WARNING,
+ return anyChars.compileWarning(std::move(metadata), std::move(notes), JSREPORT_STRICT | JSREPORT_WARNING,
errorNumber, *args);
}
template<typename CharT, class AnyCharsAccess>
void
TokenStreamSpecific<CharT, AnyCharsAccess>::error(unsigned errorNumber, ...)
{
va_list args;
va_start(args, errorNumber);
ErrorMetadata metadata;
if (computeErrorMetadata(&metadata, sourceUnits.offset())) {
TokenStreamAnyChars& anyChars = anyCharsAccess();
- ReportCompileError(anyChars.cx, Move(metadata), nullptr, JSREPORT_ERROR, errorNumber,
+ ReportCompileError(anyChars.cx, std::move(metadata), nullptr, JSREPORT_ERROR, errorNumber,
args);
}
va_end(args);
}
template<typename CharT, class AnyCharsAccess>
void
TokenStreamSpecific<CharT, AnyCharsAccess>::errorAtVA(uint32_t offset, unsigned errorNumber, va_list *args)
{
ErrorMetadata metadata;
if (computeErrorMetadata(&metadata, offset)) {
TokenStreamAnyChars& anyChars = anyCharsAccess();
- ReportCompileError(anyChars.cx, Move(metadata), nullptr, JSREPORT_ERROR, errorNumber,
+ ReportCompileError(anyChars.cx, std::move(metadata), nullptr, JSREPORT_ERROR, errorNumber,
*args);
}
}
template<typename CharT, class AnyCharsAccess>
void
TokenStreamSpecific<CharT, AnyCharsAccess>::errorAt(uint32_t offset, unsigned errorNumber, ...)
--- a/js/src/gc/Barrier.h
+++ b/js/src/gc/Barrier.h
@@ -622,17 +622,17 @@ class ReadBarriered : public ReadBarrier
// not escape, so no read barrier is necessary.
explicit ReadBarriered(const ReadBarriered& v) : ReadBarrieredBase<T>(v) {
this->post(JS::SafelyInitialized<T>(), v.unbarrieredGet());
}
// Move retains the lifetime status of the source edge, so does not fire
// the read barrier of the defunct edge.
ReadBarriered(ReadBarriered&& v)
- : ReadBarrieredBase<T>(mozilla::Move(v))
+ : ReadBarrieredBase<T>(std::move(v))
{
this->post(JS::SafelyInitialized<T>(), v.value);
}
~ReadBarriered() {
this->post(this->value, JS::SafelyInitialized<T>());
}
--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -4695,17 +4695,17 @@ js::gc::MarkingValidator::nonIncremental
return;
for (GCZonesIter zone(runtime); !zone.done(); zone.next()) {
if (!WeakMapBase::saveZoneMarkedWeakMaps(zone, markedWeakMaps))
return;
AutoEnterOOMUnsafeRegion oomUnsafe;
for (gc::WeakKeyTable::Range r = zone->gcWeakKeys().all(); !r.empty(); r.popFront()) {
- if (!savedWeakKeys.put(Move(r.front().key), Move(r.front().value)))
+ if (!savedWeakKeys.put(std::move(r.front().key), std::move(r.front().value)))
oomUnsafe.crash("saving weak keys table for validator");
}
if (!zone->gcWeakKeys().clear())
oomUnsafe.crash("clearing weak keys table for validator");
}
/*
@@ -4785,17 +4785,17 @@ js::gc::MarkingValidator::nonIncremental
oomUnsafe.crash("clearing weak keys table for validator");
}
WeakMapBase::restoreMarkedWeakMaps(markedWeakMaps);
for (gc::WeakKeyTable::Range r = savedWeakKeys.all(); !r.empty(); r.popFront()) {
AutoEnterOOMUnsafeRegion oomUnsafe;
Zone* zone = gc::TenuredCell::fromPointer(r.front().key.asCell())->zone();
- if (!zone->gcWeakKeys().put(Move(r.front().key), Move(r.front().value)))
+ if (!zone->gcWeakKeys().put(std::move(r.front().key), std::move(r.front().value)))
oomUnsafe.crash("restoring weak keys table for validator");
}
gc->incrementalState = state;
}
void
js::gc::MarkingValidator::validate()
@@ -5379,17 +5379,17 @@ class ImmediateSweepWeakCacheTask : publ
ImmediateSweepWeakCacheTask(const ImmediateSweepWeakCacheTask&) = delete;
public:
ImmediateSweepWeakCacheTask(JSRuntime* rt, JS::detail::WeakCacheBase& wc)
: GCParallelTaskHelper(rt), cache(wc)
{}
ImmediateSweepWeakCacheTask(ImmediateSweepWeakCacheTask&& other)
- : GCParallelTaskHelper(Move(other)), cache(other.cache)
+ : GCParallelTaskHelper(std::move(other)), cache(other.cache)
{}
void run() {
cache.sweep();
}
};
static void
@@ -5452,17 +5452,17 @@ SweepCompressionTasks(GCParallelTask* ta
JSRuntime* runtime = task->runtime();
AutoLockHelperThreadState lock;
// Attach finished compression tasks.
auto& finished = HelperThreadState().compressionFinishedList(lock);
for (size_t i = 0; i < finished.length(); i++) {
if (finished[i]->runtimeMatches(runtime)) {
- UniquePtr<SourceCompressionTask> compressionTask(Move(finished[i]));
+ UniquePtr<SourceCompressionTask> compressionTask(std::move(finished[i]));
HelperThreadState().remove(finished, &i);
compressionTask->complete();
}
}
// Sweep pending tasks that are holding onto should-be-dead ScriptSources.
auto& pending = HelperThreadState().compressionPendingList(lock);
for (size_t i = 0; i < pending.length(); i++) {
@@ -6328,17 +6328,17 @@ class SweepActionMaybeYield final : publ
using Action = SweepAction<GCRuntime*, Args...>;
ZealMode mode;
UniquePtr<Action> action;
bool triggered;
public:
SweepActionMaybeYield(UniquePtr<Action> action, ZealMode mode)
- : mode(mode), action(Move(action)), triggered(false) {}
+ : mode(mode), action(std::move(action)), triggered(false) {}
IncrementalProgress run(GCRuntime* gc, Args... args) override {
if (!triggered && gc->shouldYieldForZeal(mode)) {
triggered = true;
return NotFinished;
}
triggered = false;
@@ -6361,17 +6361,17 @@ class SweepActionSequence final : public
using Iter = IncrementalIter<ContainerIter<ActionVector>>;
ActionVector actions;
typename Iter::State iterState;
public:
bool init(UniquePtr<Action>* acts, size_t count) {
for (size_t i = 0; i < count; i++) {
- if (!actions.emplaceBack(Move(acts[i])))
+ if (!actions.emplaceBack(std::move(acts[i])))
return false;
}
return true;
}
IncrementalProgress run(Args... args) override {
for (Iter iter(iterState, actions); !iter.done(); iter.next()) {
if (iter.get()->run(args...) == NotFinished)
@@ -6395,17 +6395,17 @@ class SweepActionForEach final : public
using IncrIter = IncrementalIter<Iter>;
Init iterInit;
UniquePtr<Action> action;
typename IncrIter::State iterState;
public:
SweepActionForEach(const Init& init, UniquePtr<Action> action)
- : iterInit(init), action(Move(action))
+ : iterInit(init), action(std::move(action))
{}
IncrementalProgress run(Args... args) override {
for (IncrIter iter(iterState, iterInit); !iter.done(); iter.next()) {
if (action->run(args..., iter.get()) == NotFinished)
return NotFinished;
}
return Finished;
@@ -6425,17 +6425,17 @@ class SweepActionRepeatFor final : publi
using IncrIter = IncrementalIter<Iter>;
Init iterInit;
UniquePtr<Action> action;
typename IncrIter::State iterState;
public:
SweepActionRepeatFor(const Init& init, UniquePtr<Action> action)
- : iterInit(init), action(Move(action))
+ : iterInit(init), action(std::move(action))
{}
IncrementalProgress run(Args... args) override {
for (IncrIter iter(iterState, iterInit); !iter.done(); iter.next()) {
if (action->run(args...) == NotFinished)
return NotFinished;
}
return Finished;
@@ -6489,67 +6489,67 @@ static UniquePtr<SweepAction<GCRuntime*,
Call(IncrementalProgress (GCRuntime::*method)(Args...)) {
return MakeUnique<SweepActionCall<Args...>>(method);
}
template <typename... Args>
static UniquePtr<SweepAction<GCRuntime*, Args...>>
MaybeYield(ZealMode zealMode, UniquePtr<SweepAction<GCRuntime*, Args...>> action) {
#ifdef JS_GC_ZEAL
- return js::MakeUnique<SweepActionMaybeYield<Args...>>(Move(action), zealMode);
+ return js::MakeUnique<SweepActionMaybeYield<Args...>>(std::move(action), zealMode);
#else
return action;
#endif
}
template <typename... Args, typename... Rest>
static UniquePtr<SweepAction<Args...>>
Sequence(UniquePtr<SweepAction<Args...>> first, Rest... rest)
{
- UniquePtr<SweepAction<Args...>> actions[] = { Move(first), Move(rest)... };
+ UniquePtr<SweepAction<Args...>> actions[] = { std::move(first), std::move(rest)... };
auto seq = MakeUnique<SweepActionSequence<Args...>>();
if (!seq || !seq->init(actions, ArrayLength(actions)))
return nullptr;
- return UniquePtr<SweepAction<Args...>>(Move(seq));
+ return UniquePtr<SweepAction<Args...>>(std::move(seq));
}
template <typename... Args>
static UniquePtr<SweepAction<Args...>>
RepeatForSweepGroup(JSRuntime* rt, UniquePtr<SweepAction<Args...>> action)
{
if (!action)
return nullptr;
using Action = SweepActionRepeatFor<SweepGroupsIter, JSRuntime*, Args...>;
- return js::MakeUnique<Action>(rt, Move(action));
+ return js::MakeUnique<Action>(rt, std::move(action));
}
template <typename... Args>
static UniquePtr<typename RemoveLastTemplateParameter<SweepAction<Args...>>::Type>
ForEachZoneInSweepGroup(JSRuntime* rt, UniquePtr<SweepAction<Args...>> action)
{
if (!action)
return nullptr;
using Action = typename RemoveLastTemplateParameter<
SweepActionForEach<SweepGroupZonesIter, JSRuntime*, Args...>>::Type;
- return js::MakeUnique<Action>(rt, Move(action));
+ return js::MakeUnique<Action>(rt, std::move(action));
}
template <typename... Args>
static UniquePtr<typename RemoveLastTemplateParameter<SweepAction<Args...>>::Type>
ForEachAllocKind(AllocKinds kinds, UniquePtr<SweepAction<Args...>> action)
{
if (!action)
return nullptr;
using Action = typename RemoveLastTemplateParameter<
SweepActionForEach<ContainerIter<AllocKinds>, AllocKinds, Args...>>::Type;
- return js::MakeUnique<Action>(kinds, Move(action));
+ return js::MakeUnique<Action>(kinds, std::move(action));
}
} // namespace sweepaction
bool
GCRuntime::initSweepActions()
{
using namespace sweepaction;
@@ -8126,18 +8126,18 @@ GCRuntime::mergeRealms(Realm* source, Re
oomUnsafe.crash("Failed to create a script name map.");
if (!target->scriptNameMap->init())
oomUnsafe.crash("Failed to initialize a script name map.");
}
for (ScriptNameMap::Range r = source->scriptNameMap->all(); !r.empty(); r.popFront()) {
JSScript* key = r.front().key();
- auto value = Move(r.front().value());
- if (!target->scriptNameMap->putNew(key, Move(value)))
+ auto value = std::move(r.front().value());
+ if (!target->scriptNameMap->putNew(key, std::move(value)))
oomUnsafe.crash("Failed to add an entry in the script name map.");
}
source->scriptNameMap->clear();
}
// The source realm is now completely empty, and is the only realm in its
// compartment, which is the only compartment in its zone. Delete realm,
--- a/js/src/gc/GCParallelTask.h
+++ b/js/src/gc/GCParallelTask.h
@@ -137,17 +137,17 @@ class GCParallelTask
template <typename Derived>
class GCParallelTaskHelper : public GCParallelTask
{
public:
explicit GCParallelTaskHelper(JSRuntime* runtime)
: GCParallelTask(runtime, &runTaskTyped)
{}
GCParallelTaskHelper(GCParallelTaskHelper&& other)
- : GCParallelTask(mozilla::Move(other))
+ : GCParallelTask(std::move(other))
{}
private:
static void runTaskTyped(GCParallelTask* task) {
static_cast<Derived*>(task)->run();
}
};
--- a/js/src/gc/NurseryAwareHashMap.h
+++ b/js/src/gc/NurseryAwareHashMap.h
@@ -22,17 +22,17 @@ namespace detail {
template <typename T>
class UnsafeBareReadBarriered : public ReadBarrieredBase<T>
{
public:
UnsafeBareReadBarriered() : ReadBarrieredBase<T>(JS::SafelyInitialized<T>()) {}
MOZ_IMPLICIT UnsafeBareReadBarriered(const T& v) : ReadBarrieredBase<T>(v) {}
explicit UnsafeBareReadBarriered(const UnsafeBareReadBarriered& v) : ReadBarrieredBase<T>(v) {}
UnsafeBareReadBarriered(UnsafeBareReadBarriered&& v)
- : ReadBarrieredBase<T>(mozilla::Move(v))
+ : ReadBarrieredBase<T>(std::move(v))
{}
UnsafeBareReadBarriered& operator=(const UnsafeBareReadBarriered& v) {
this->value = v.value;
return *this;
}
UnsafeBareReadBarriered& operator=(const T& v) {
--- a/js/src/gc/WeakMap.h
+++ b/js/src/gc/WeakMap.h
@@ -232,22 +232,22 @@ class WeakMap : public HashMap<Key, Valu
protected:
static void addWeakEntry(GCMarker* marker, JS::GCCellPtr key, gc::WeakMarkable markable)
{
Zone* zone = key.asCell()->asTenured().zone();
auto p = zone->gcWeakKeys().get(key);
if (p) {
gc::WeakEntryVector& weakEntries = p->value;
- if (!weakEntries.append(Move(markable)))
+ if (!weakEntries.append(std::move(markable)))
marker->abortLinearWeakMarking();
} else {
gc::WeakEntryVector weakEntries;
- MOZ_ALWAYS_TRUE(weakEntries.append(Move(markable)));
- if (!zone->gcWeakKeys().put(JS::GCCellPtr(key), Move(weakEntries)))
+ MOZ_ALWAYS_TRUE(weakEntries.append(std::move(markable)));
+ if (!zone->gcWeakKeys().put(JS::GCCellPtr(key), std::move(weakEntries)))
marker->abortLinearWeakMarking();
}
}
bool markIteratively(GCMarker* marker) override {
MOZ_ASSERT(marked);
bool markedAny = false;
--- a/js/src/irregexp/NativeRegExpMacroAssembler.cpp
+++ b/js/src/irregexp/NativeRegExpMacroAssembler.cpp
@@ -962,17 +962,17 @@ NativeRegExpMacroAssembler::CheckBitInTa
masm.and32(current_character, temp1);
masm.load8ZeroExtend(BaseIndex(temp0, temp1, TimesOne), temp0);
masm.branchTest32(Assembler::NonZero, temp0, temp0, BranchOrBacktrack(on_bit_set));
// Transfer ownership of |table| to the |tables| Vector.
{
AutoEnterOOMUnsafeRegion oomUnsafe;
- if (!tables.append(Move(table)))
+ if (!tables.append(std::move(table)))
oomUnsafe.crash("RegExp table append");
}
}
void
NativeRegExpMacroAssembler::Fail()
{
JitSpew(SPEW_PREFIX "Fail");
--- a/js/src/irregexp/RegExpEngine.cpp
+++ b/js/src/irregexp/RegExpEngine.cpp
@@ -1048,17 +1048,17 @@ ChoiceNode::FilterLATIN1(int depth, bool
RegExpNode* replacement =
alternatives()[i].node()->FilterLATIN1(depth - 1, ignore_case, unicode);
if (replacement != nullptr) {
alternatives()[i].set_node(replacement);
new_alternatives.append(alternatives()[i]);
}
}
- alternatives_ = Move(new_alternatives);
+ alternatives_ = std::move(new_alternatives);
return this;
}
// -------------------------------------------------------------------
// NegativeLookaheadChoiceNode
bool
NegativeLookaheadChoiceNode::FillInBMInfo(int offset,
@@ -2528,17 +2528,17 @@ BoyerMooreLookahead::EmitSkipInstruction
}
int skip_distance = GetSkipTable(min_lookahead, max_lookahead, boolean_skip_table.get());
MOZ_ASSERT(skip_distance != 0);
jit::Label cont, again;
masm->Bind(&again);
masm->LoadCurrentCharacter(max_lookahead, &cont, true);
- masm->CheckBitInTable(Move(boolean_skip_table), &cont);
+ masm->CheckBitInTable(std::move(boolean_skip_table), &cont);
masm->AdvanceCurrentPosition(skip_distance);
masm->JumpOrBacktrack(&again);
masm->Bind(&cont);
return true;
}
bool
@@ -3326,17 +3326,17 @@ EmitUseLookupTable(RegExpMacroAssembler*
ba.reset(static_cast<uint8_t*>(js_malloc(kSize)));
if (!ba)
oomUnsafe.crash("Table malloc");
}
for (int i = 0; i < kSize; i++)
ba[i] = templ[i];
- masm->CheckBitInTable(Move(ba), on_bit_set);
+ masm->CheckBitInTable(std::move(ba), on_bit_set);
if (on_bit_clear != fall_through)
masm->JumpOrBacktrack(on_bit_clear);
}
static void
CutOutRange(RegExpMacroAssembler* masm,
RangeBoundaryVector& ranges,
int start_index,
--- a/js/src/irregexp/RegExpEngine.h
+++ b/js/src/irregexp/RegExpEngine.h
@@ -152,17 +152,17 @@ class InfallibleVector
T popCopy() { return vector_.popCopy(); }
T* begin() { return vector_.begin(); }
const T* begin() const { return vector_.begin(); }
T& operator[](size_t index) { return vector_[index]; }
const T& operator[](size_t index) const { return vector_[index]; }
- InfallibleVector& operator=(InfallibleVector&& rhs) { vector_ = Move(rhs.vector_); return *this; }
+ InfallibleVector& operator=(InfallibleVector&& rhs) { vector_ = std::move(rhs.vector_); return *this; }
};
class CharacterRange;
typedef InfallibleVector<CharacterRange, 1> CharacterRangeVector;
// Represents code units in the range from from_ to to_, both ends are
// inclusive.
class CharacterRange
--- a/js/src/irregexp/RegExpParser.cpp
+++ b/js/src/irregexp/RegExpParser.cpp
@@ -301,17 +301,17 @@ RegExpParser<CharT>::SyntaxError(unsigne
return;
err.lineLength = windowLength;
err.tokenOffset = offset - (windowStart - start_);
va_list args;
va_start(args, errorNumber);
- ReportCompileError(ts.context(), Move(err), nullptr, JSREPORT_ERROR, errorNumber, args);
+ ReportCompileError(ts.context(), std::move(err), nullptr, JSREPORT_ERROR, errorNumber, args);
va_end(args);
}
template <typename CharT>
RegExpTree*
RegExpParser<CharT>::ReportError(unsigned errorNumber, const char* param /* = nullptr */)
{
--- a/js/src/jit/AliasAnalysis.cpp
+++ b/js/src/jit/AliasAnalysis.cpp
@@ -136,17 +136,17 @@ AliasAnalysis::analyze()
Vector<MInstructionVector, AliasSet::NumCategories, JitAllocPolicy> stores(alloc());
// Initialize to the first instruction.
MInstruction* firstIns = *graph_.entryBlock()->begin();
for (unsigned i = 0; i < AliasSet::NumCategories; i++) {
MInstructionVector defs(alloc());
if (!defs.append(firstIns))
return false;
- if (!stores.append(Move(defs)))
+ if (!stores.append(std::move(defs)))
return false;
}
// Type analysis may have inserted new instructions. Since this pass depends
// on the instruction number ordering, all instructions are renumbered.
uint32_t newId = 0;
for (ReversePostorderIterator block(graph_.rpoBegin()); block != graph_.rpoEnd(); block++) {
--- a/js/src/jit/BacktrackingAllocator.cpp
+++ b/js/src/jit/BacktrackingAllocator.cpp
@@ -2355,40 +2355,40 @@ BacktrackingAllocator::annotateMoveGroup
UniqueChars
LiveRange::toString() const
{
AutoEnterOOMUnsafeRegion oomUnsafe;
UniqueChars buf = JS_smprintf("v%u [%u,%u)", hasVreg() ? vreg() : 0, from().bits(), to().bits());
if (buf && bundle() && !bundle()->allocation().isBogus())
- buf = JS_sprintf_append(Move(buf), " %s", bundle()->allocation().toString().get());
+ buf = JS_sprintf_append(std::move(buf), " %s", bundle()->allocation().toString().get());
if (buf && hasDefinition())
- buf = JS_sprintf_append(Move(buf), " (def)");
+ buf = JS_sprintf_append(std::move(buf), " (def)");
for (UsePositionIterator iter = usesBegin(); buf && iter; iter++)
- buf = JS_sprintf_append(Move(buf), " %s@%u", iter->use()->toString().get(), iter->pos.bits());
+ buf = JS_sprintf_append(std::move(buf), " %s@%u", iter->use()->toString().get(), iter->pos.bits());
if (!buf)
oomUnsafe.crash("LiveRange::toString()");
return buf;
}
UniqueChars
LiveBundle::toString() const
{
AutoEnterOOMUnsafeRegion oomUnsafe;
// Suppress -Wformat warning.
UniqueChars buf = JS_smprintf("%s", "");
for (LiveRange::BundleLinkIterator iter = rangesBegin(); buf && iter; iter++) {
- buf = JS_sprintf_append(Move(buf), "%s %s",
+ buf = JS_sprintf_append(std::move(buf), "%s %s",
(iter == rangesBegin()) ? "" : " ##",
LiveRange::get(*iter)->toString().get());
}
if (!buf)
oomUnsafe.crash("LiveBundle::toString()");
return buf;
--- a/js/src/jit/CacheIRCompiler.cpp
+++ b/js/src/jit/CacheIRCompiler.cpp
@@ -1221,17 +1221,17 @@ CacheIRCompiler::addFailurePath(FailureP
// Reuse the previous failure path if the current one is the same, to
// avoid emitting duplicate code.
if (failurePaths.length() > 0 && failurePaths.back().canShareFailurePath(newFailure)) {
*failure = &failurePaths.back();
return true;
}
- if (!failurePaths.append(Move(newFailure)))
+ if (!failurePaths.append(std::move(newFailure)))
return false;
*failure = &failurePaths.back();
return true;
}
bool
CacheIRCompiler::emitFailurePath(size_t index)
--- a/js/src/jit/CacheIRCompiler.h
+++ b/js/src/jit/CacheIRCompiler.h
@@ -524,18 +524,18 @@ class FailurePath
SpilledRegisterVector spilledRegs_;
NonAssertingLabel label_;
uint32_t stackPushed_;
public:
FailurePath() = default;
FailurePath(FailurePath&& other)
- : inputs_(Move(other.inputs_)),
- spilledRegs_(Move(other.spilledRegs_)),
+ : inputs_(std::move(other.inputs_)),
+ spilledRegs_(std::move(other.spilledRegs_)),
label_(other.label_),
stackPushed_(other.stackPushed_)
{}
Label* label() { return &label_; }
void setStackPushed(uint32_t i) { stackPushed_ = i; }
uint32_t stackPushed() const { return stackPushed_; }
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -11630,24 +11630,24 @@ class OutOfLineSwitch : public OutOfLine
// Register an entry in the switch table.
void addTableEntry(MacroAssembler& masm) {
if ((!isOutOfLine_ && tableType == SwitchTableType::Inline) ||
(isOutOfLine_ && tableType == SwitchTableType::OutOfLine))
{
CodeLabel cl;
masm.writeCodePointer(&cl);
- masm.propagateOOM(codeLabels_.append(mozilla::Move(cl)));
+ masm.propagateOOM(codeLabels_.append(std::move(cl)));
}
}
// Register the code, to which the table will jump to.
void addCodeEntry(MacroAssembler& masm) {
Label entry;
masm.bind(&entry);
- masm.propagateOOM(labels_.append(mozilla::Move(entry)));
+ masm.propagateOOM(labels_.append(std::move(entry)));
}
void setOutOfLine() {
isOutOfLine_ = true;
}
};
template <SwitchTableType tableType>
--- a/js/src/jit/IonCode.h
+++ b/js/src/jit/IonCode.h
@@ -423,17 +423,17 @@ struct IonScript
void clearHasProfilingInstrumentation() {
hasProfilingInstrumentation_ = false;
}
bool hasProfilingInstrumentation() const {
return hasProfilingInstrumentation_;
}
MOZ_MUST_USE bool addTraceLoggerEvent(TraceLoggerEvent& event) {
MOZ_ASSERT(event.hasTextId());
- return traceLoggerEvents_.append(mozilla::Move(event));
+ return traceLoggerEvents_.append(std::move(event));
}
const uint8_t* snapshots() const {
return reinterpret_cast<const uint8_t*>(this) + snapshots_;
}
size_t snapshotsListSize() const {
return snapshotsListSize_;
}
size_t snapshotsRVATableSize() const {
--- a/js/src/jit/IonControlFlow.cpp
+++ b/js/src/jit/IonControlFlow.cpp
@@ -77,17 +77,17 @@ ControlFlowGraph::init(TempAllocator& al
return false;
for (size_t i = 0; i < blocks.length(); i++) {
MOZ_ASSERT(blocks[i]->id() == i);
CFGBlock block(blocks[i]->startPc());
block.setStopPc(blocks[i]->stopPc());
block.setId(i);
- blocks_.infallibleAppend(mozilla::Move(block));
+ blocks_.infallibleAppend(std::move(block));
}
for (size_t i = 0; i < blocks.length(); i++) {
if (!alloc.ensureBallast())
return false;
CFGControlInstruction* copy = nullptr;
CFGControlInstruction* ins = blocks[i]->stopIns();
--- a/js/src/jit/JitFrames.cpp
+++ b/js/src/jit/JitFrames.cpp
@@ -1445,29 +1445,29 @@ OsiIndex::returnPointDisplacement() cons
RInstructionResults::RInstructionResults(JitFrameLayout* fp)
: results_(nullptr),
fp_(fp),
initialized_(false)
{
}
RInstructionResults::RInstructionResults(RInstructionResults&& src)
- : results_(mozilla::Move(src.results_)),
+ : results_(std::move(src.results_)),
fp_(src.fp_),
initialized_(src.initialized_)
{
src.initialized_ = false;
}
RInstructionResults&
RInstructionResults::operator=(RInstructionResults&& rhs)
{
MOZ_ASSERT(&rhs != this, "self-moves are prohibited");
this->~RInstructionResults();
- new(this) RInstructionResults(mozilla::Move(rhs));
+ new(this) RInstructionResults(std::move(rhs));
return *this;
}
RInstructionResults::~RInstructionResults()
{
// results_ is freed by the UniquePtr.
}
@@ -1928,17 +1928,17 @@ SnapshotIterator::initInstructionResults
"Observe recovered instruction.");
}
// Register the list of result on the activation. We need to do that
// before we initialize the list such as if any recover instruction
// cause a GC, we can ensure that the results are properly traced by the
// activation.
RInstructionResults tmp(fallback.frame->jsFrame());
- if (!fallback.activation->registerIonFrameRecovery(mozilla::Move(tmp)))
+ if (!fallback.activation->registerIonFrameRecovery(std::move(tmp)))
return false;
results = fallback.activation->maybeIonFrameRecovery(fp);
// Start a new snapshot at the beginning of the JSJitFrameIter. This
// SnapshotIterator is used for evaluating the content of all recover
// instructions. The result is then saved on the JitActivation.
MachineState machine = fallback.frame->machineState();
--- a/js/src/jit/JitRealm.h
+++ b/js/src/jit/JitRealm.h
@@ -346,20 +346,20 @@ struct CacheIRStubKey : public DefaultHa
};
static HashNumber hash(const Lookup& l);
static bool match(const CacheIRStubKey& entry, const Lookup& l);
UniquePtr<CacheIRStubInfo, JS::FreePolicy> stubInfo;
explicit CacheIRStubKey(CacheIRStubInfo* info) : stubInfo(info) {}
- CacheIRStubKey(CacheIRStubKey&& other) : stubInfo(Move(other.stubInfo)) { }
+ CacheIRStubKey(CacheIRStubKey&& other) : stubInfo(std::move(other.stubInfo)) { }
void operator=(CacheIRStubKey&& other) {
- stubInfo = Move(other.stubInfo);
+ stubInfo = std::move(other.stubInfo);
}
};
template<typename Key>
struct IcStubCodeMapGCPolicy
{
static bool needsSweep(Key*, ReadBarrieredJitCode* value) {
return IsAboutToBeFinalized(value);
@@ -412,33 +412,33 @@ class JitZone
return nullptr;
}
MOZ_MUST_USE bool putBaselineCacheIRStubCode(const CacheIRStubKey::Lookup& lookup,
CacheIRStubKey& key,
JitCode* stubCode)
{
auto p = baselineCacheIRStubCodes_.lookupForAdd(lookup);
MOZ_ASSERT(!p);
- return baselineCacheIRStubCodes_.add(p, Move(key), stubCode);
+ return baselineCacheIRStubCodes_.add(p, std::move(key), stubCode);
}
CacheIRStubInfo* getIonCacheIRStubInfo(const CacheIRStubKey::Lookup& key) {
if (!ionCacheIRStubInfoSet_.initialized())
return nullptr;
IonCacheIRStubInfoSet::Ptr p = ionCacheIRStubInfoSet_.lookup(key);
return p ? p->stubInfo.get() : nullptr;
}
MOZ_MUST_USE bool putIonCacheIRStubInfo(const CacheIRStubKey::Lookup& lookup,
CacheIRStubKey& key)
{
if (!ionCacheIRStubInfoSet_.initialized() && !ionCacheIRStubInfoSet_.init())
return false;
IonCacheIRStubInfoSet::AddPtr p = ionCacheIRStubInfoSet_.lookupForAdd(lookup);
MOZ_ASSERT(!p);
- return ionCacheIRStubInfoSet_.add(p, Move(key));
+ return ionCacheIRStubInfoSet_.add(p, std::move(key));
}
void purgeIonCacheIRStubInfo() {
ionCacheIRStubInfoSet_.finish();
}
};
enum class BailoutReturnStub {
GetProp,
--- a/js/src/jit/LIR.cpp
+++ b/js/src/jit/LIR.cpp
@@ -399,19 +399,19 @@ LDefinition::toString() const
UniqueChars buf;
if (isBogusTemp()) {
buf = JS_smprintf("bogus");
} else {
buf = JS_smprintf("v%u<%s>", virtualRegister(), DefTypeName(type()));
if (buf) {
if (policy() == LDefinition::FIXED)
- buf = JS_sprintf_append(Move(buf), ":%s", output()->toString().get());
+ buf = JS_sprintf_append(std::move(buf), ":%s", output()->toString().get());
else if (policy() == LDefinition::MUST_REUSE_INPUT)
- buf = JS_sprintf_append(Move(buf), ":tied(%u)", getReusedInput());
+ buf = JS_sprintf_append(std::move(buf), ":tied(%u)", getReusedInput());
}
}
if (!buf)
oomUnsafe.crash("LDefinition::toString()");
return buf;
}
--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -257,17 +257,17 @@ class MUse : public TempObject, public I
// Default constructor for use in vectors.
MUse()
: producer_(nullptr), consumer_(nullptr)
{ }
// Move constructor for use in vectors. When an MUse is moved, it stays
// in its containing use list.
MUse(MUse&& other)
- : InlineListNode<MUse>(mozilla::Move(other)),
+ : InlineListNode<MUse>(std::move(other)),
producer_(other.producer_), consumer_(other.consumer_)
{ }
// Construct an MUse initialized with |producer| and |consumer|.
MUse(MDefinition* producer, MNode* consumer)
{
initUnchecked(producer, consumer);
}
--- a/js/src/jit/MIRGraph.cpp
+++ b/js/src/jit/MIRGraph.cpp
@@ -95,24 +95,24 @@ MIRGenerator::abort(AbortReason r)
case AbortReason::Error:
JitSpew(JitSpew_IonAbort, "AbortReason::Error");
break;
case AbortReason::NoAbort:
MOZ_CRASH("Abort with AbortReason::NoAbort");
break;
}
}
- return Err(mozilla::Move(r));
+ return Err(std::move(r));
}
mozilla::GenericErrorResult<AbortReason>
MIRGenerator::abortFmt(AbortReason r, const char* message, va_list ap)
{
JitSpewVA(JitSpew_IonAbort, message, ap);
- return Err(mozilla::Move(r));
+ return Err(std::move(r));
}
mozilla::GenericErrorResult<AbortReason>
MIRGenerator::abort(AbortReason r, const char* message, ...)
{
va_list ap;
va_start(ap, message);
auto forward = abortFmt(r, message, ap);
--- a/js/src/jit/OptimizationTracking.cpp
+++ b/js/src/jit/OptimizationTracking.cpp
@@ -27,17 +27,17 @@ using JS::TrackedStrategy;
using JS::TrackedOutcome;
using JS::TrackedTypeSite;
using JS::ForEachTrackedOptimizationAttemptOp;
using JS::ForEachTrackedOptimizationTypeInfoOp;
bool
TrackedOptimizations::trackTypeInfo(OptimizationTypeInfo&& ty)
{
- return types_.append(mozilla::Move(ty));
+ return types_.append(std::move(ty));
}
bool
TrackedOptimizations::trackAttempt(TrackedStrategy strategy)
{
OptimizationAttempt attempt(strategy, TrackedOutcome::GenericFailure);
currentAttempt_ = attempts_.length();
return attempts_.append(attempt);
@@ -1097,29 +1097,29 @@ IonBuilder::trackTypeInfoUnchecked(Track
{
BytecodeSite* site = current->trackedSite();
// OOMs are handled as if optimization tracking were turned off.
OptimizationTypeInfo typeInfo(alloc(), kind, mirType);
if (!typeInfo.trackTypeSet(typeSet)) {
site->setOptimizations(nullptr);
return;
}
- if (!site->optimizations()->trackTypeInfo(mozilla::Move(typeInfo)))
+ if (!site->optimizations()->trackTypeInfo(std::move(typeInfo)))
site->setOptimizations(nullptr);
}
void
IonBuilder::trackTypeInfoUnchecked(TrackedTypeSite kind, JSObject* obj)
{
BytecodeSite* site = current->trackedSite();
// OOMs are handled as if optimization tracking were turned off.
OptimizationTypeInfo typeInfo(alloc(), kind, MIRType::Object);
if (!typeInfo.trackType(TypeSet::ObjectType(obj)))
return;
- if (!site->optimizations()->trackTypeInfo(mozilla::Move(typeInfo)))
+ if (!site->optimizations()->trackTypeInfo(std::move(typeInfo)))
site->setOptimizations(nullptr);
}
void
IonBuilder::trackTypeInfoUnchecked(CallInfo& callInfo)
{
MDefinition* thisArg = callInfo.thisArg();
trackTypeInfoUnchecked(TrackedTypeSite::Call_This, thisArg->type(), thisArg->resultTypeSet());
--- a/js/src/jit/OptimizationTracking.h
+++ b/js/src/jit/OptimizationTracking.h
@@ -62,17 +62,17 @@ class OptimizationTypeInfo
JS::TrackedTypeSite site_;
MIRType mirType_;
TempTypeList types_;
public:
OptimizationTypeInfo(OptimizationTypeInfo&& other)
: site_(other.site_),
mirType_(other.mirType_),
- types_(mozilla::Move(other.types_))
+ types_(std::move(other.types_))
{ }
OptimizationTypeInfo(TempAllocator& alloc, JS::TrackedTypeSite site, MIRType mirType)
: site_(site),
mirType_(mirType),
types_(alloc)
{ }
--- a/js/src/jit/RematerializedFrame.cpp
+++ b/js/src/jit/RematerializedFrame.cpp
@@ -98,17 +98,17 @@ RematerializedFrame::RematerializeInline
return false;
}
if (!iter.more())
break;
++iter;
}
- frames = Move(tempFrames.get());
+ frames = std::move(tempFrames.get());
return true;
}
/* static */ void
RematerializedFrame::FreeInVector(GCVector<RematerializedFrame*>& frames)
{
for (size_t i = 0; i < frames.length(); i++) {
RematerializedFrame* f = frames[i];
--- a/js/src/jit/arm64/vixl/Debugger-vixl.cpp
+++ b/js/src/jit/arm64/vixl/Debugger-vixl.cpp
@@ -399,30 +399,30 @@ class ExamineCommand : public DebugComma
Token* target_;
FormatToken* format_;
IntegerToken* count_;
};
// Commands which name does not match any of the known commnand.
class UnknownCommand : public DebugCommand {
public:
- explicit UnknownCommand(TokenVector&& args) : args_(Move(args)) {}
+ explicit UnknownCommand(TokenVector&& args) : args_(std::move(args)) {}
virtual ~UnknownCommand();
virtual bool Run(Debugger* debugger) override;
private:
TokenVector args_;
};
// Commands which name match a known command but the syntax is invalid.
class InvalidCommand : public DebugCommand {
public:
InvalidCommand(TokenVector&& args, int index, const char* cause)
- : args_(Move(args)), index_(index), cause_(cause) {}
+ : args_(std::move(args)), index_(index), cause_(cause) {}
virtual ~InvalidCommand();
virtual bool Run(Debugger* debugger) override;
private:
TokenVector args_;
int index_;
const char* cause_;
@@ -1134,28 +1134,28 @@ DebugCommand* DebugCommand::Parse(char*
}
}
if (args.empty()) {
return NULL;
}
if (!args[0]->IsIdentifier()) {
- return js_new<InvalidCommand>(Move(args), 0, "command name is not valid");
+ return js_new<InvalidCommand>(std::move(args), 0, "command name is not valid");
}
const char* name = IdentifierToken::Cast(args[0])->value();
#define RETURN_IF_MATCH(Command) \
if (Match(name, Command::kAliases)) { \
- return Command::Build(Move(args)); \
+ return Command::Build(std::move(args)); \
}
DEBUG_COMMAND_LIST(RETURN_IF_MATCH);
#undef RETURN_IF_MATCH
- return js_new<UnknownCommand>(Move(args));
+ return js_new<UnknownCommand>(std::move(args));
}
void DebugCommand::PrintHelp(const char** aliases,
const char* args,
const char* help) {
VIXL_ASSERT(aliases[0] != NULL);
VIXL_ASSERT(help != NULL);
@@ -1185,34 +1185,34 @@ bool HelpCommand::Run(Debugger* debugger
printf("\n----\n\n");
return false;
}
DebugCommand* HelpCommand::Build(TokenVector&& args) {
if (args.length() != 1) {
- return js_new<InvalidCommand>(Move(args), -1, "too many arguments");
+ return js_new<InvalidCommand>(std::move(args), -1, "too many arguments");
}
return js_new<HelpCommand>(args[0]);
}
bool ContinueCommand::Run(Debugger* debugger) {
VIXL_ASSERT(debugger->IsDebuggerRunning());
debugger->set_debug_parameters(debugger->debug_parameters() & ~DBG_ACTIVE);
return true;
}
DebugCommand* ContinueCommand::Build(TokenVector&& args) {
if (args.length() != 1) {
- return js_new<InvalidCommand>(Move(args), -1, "too many arguments");
+ return js_new<InvalidCommand>(std::move(args), -1, "too many arguments");
}
return js_new<ContinueCommand>(args[0]);
}
bool StepCommand::Run(Debugger* debugger) {
VIXL_ASSERT(debugger->IsDebuggerRunning());
@@ -1238,47 +1238,47 @@ DebugCommand* StepCommand::Build(TokenVe
switch (args.length()) {
case 1: { // step [1]
count = js_new<IntegerToken>(1);
break;
}
case 2: { // step n
Token* first = args[1];
if (!first->IsInteger()) {
- return js_new<InvalidCommand>(Move(args), 1, "expects int");
+ return js_new<InvalidCommand>(std::move(args), 1, "expects int");
}
count = IntegerToken::Cast(first);
break;
}
default:
- return js_new<InvalidCommand>(Move(args), -1, "too many arguments");
+ return js_new<InvalidCommand>(std::move(args), -1, "too many arguments");
}
return js_new<StepCommand>(args[0], count);
}
DebugCommand* DisasmCommand::Build(TokenVector&& args) {
IntegerToken* count = NULL;
switch (args.length()) {
case 1: { // disasm [10]
count = js_new<IntegerToken>(10);
break;
}
case 2: { // disasm n
Token* first = args[1];
if (!first->IsInteger()) {
- return js_new<InvalidCommand>(Move(args), 1, "expects int");
+ return js_new<InvalidCommand>(std::move(args), 1, "expects int");
}
count = IntegerToken::Cast(first);
break;
}
default:
- return js_new<InvalidCommand>(Move(args), -1, "too many arguments");
+ return js_new<InvalidCommand>(std::move(args), -1, "too many arguments");
}
Token* target = js_new<IdentifierToken>("pc");
FormatToken* format = js_new<Format<uint32_t>>("%08" PRIx32, 'i');
return js_new<ExamineCommand>(args[0], target, format, count);
}
@@ -1333,24 +1333,24 @@ bool PrintCommand::Run(Debugger* debugge
VIXL_UNREACHABLE();
return false;
}
DebugCommand* PrintCommand::Build(TokenVector&& args) {
if (args.length() < 2) {
- return js_new<InvalidCommand>(Move(args), -1, "too few arguments");
+ return js_new<InvalidCommand>(std::move(args), -1, "too few arguments");
}
Token* target = args[1];
if (!target->IsRegister() &&
!target->IsFPRegister() &&
!target->IsIdentifier()) {
- return js_new<InvalidCommand>(Move(args), 1, "expects reg or identifier");
+ return js_new<InvalidCommand>(std::move(args), 1, "expects reg or identifier");
}
FormatToken* format = NULL;
int target_size = 0;
if (target->IsRegister()) {
Register reg = RegisterToken::Cast(target)->value();
target_size = reg.SizeInBytes();
} else if (target->IsFPRegister()) {
@@ -1374,34 +1374,34 @@ DebugCommand* PrintCommand::Build(TokenV
case 8: format = js_new<Format<double>>("%8g", 'f'); break;
default: VIXL_UNREACHABLE();
}
}
break;
}
case 3: {
if (target->IsIdentifier()) {
- return js_new<InvalidCommand>(Move(args), 2,
+ return js_new<InvalidCommand>(std::move(args), 2,
"format is only allowed with registers");
}
Token* second = args[2];
if (!second->IsFormat()) {
- return js_new<InvalidCommand>(Move(args), 2, "expects format");
+ return js_new<InvalidCommand>(std::move(args), 2, "expects format");
}
format = FormatToken::Cast(second);
if (format->SizeOf() > target_size) {
- return js_new<InvalidCommand>(Move(args), 2, "format too wide");
+ return js_new<InvalidCommand>(std::move(args), 2, "format too wide");
}
break;
}
default:
- return js_new<InvalidCommand>(Move(args), -1, "too many arguments");
+ return js_new<InvalidCommand>(std::move(args), -1, "too many arguments");
}
return js_new<PrintCommand>(args[0], target, format);
}
bool ExamineCommand::Run(Debugger* debugger) {
VIXL_ASSERT(debugger->IsDebuggerRunning());
@@ -1422,22 +1422,22 @@ void ExamineCommand::Print(FILE* out) {
fprintf(out, "%s ", name());
format()->Print(out);
target()->Print(out);
}
DebugCommand* ExamineCommand::Build(TokenVector&& args) {
if (args.length() < 2) {
- return js_new<InvalidCommand>(Move(args), -1, "too few arguments");
+ return js_new<InvalidCommand>(std::move(args), -1, "too few arguments");
}
Token* target = args[1];
if (!target->CanAddressMemory()) {
- return js_new<InvalidCommand>(Move(args), 1, "expects address");
+ return js_new<InvalidCommand>(std::move(args), 1, "expects address");
}
FormatToken* format = NULL;
IntegerToken* count = NULL;
switch (args.length()) {
case 2: { // mem addr[.x64] [10]
format = js_new<Format<uint64_t>>("%016" PRIx64, 'x');
@@ -1450,33 +1450,33 @@ DebugCommand* ExamineCommand::Build(Toke
if (second->IsFormat()) {
format = FormatToken::Cast(second);
count = js_new<IntegerToken>(10);
break;
} else if (second->IsInteger()) {
format = js_new<Format<uint64_t>>("%016" PRIx64, 'x');
count = IntegerToken::Cast(second);
} else {
- return js_new<InvalidCommand>(Move(args), 2, "expects format or integer");
+ return js_new<InvalidCommand>(std::move(args), 2, "expects format or integer");
}
VIXL_UNREACHABLE();
break;
}
case 4: { // mem addr.format n
Token* second = args[2];
Token* third = args[3];
if (!second->IsFormat() || !third->IsInteger()) {
- return js_new<InvalidCommand>(Move(args), -1, "expects addr[.format] [n]");
+ return js_new<InvalidCommand>(std::move(args), -1, "expects addr[.format] [n]");
}
format = FormatToken::Cast(second);
count = IntegerToken::Cast(third);
break;
}
default:
- return js_new<InvalidCommand>(Move(args), -1, "too many arguments");
+ return js_new<InvalidCommand>(std::move(args), -1, "too many arguments");
}
return js_new<ExamineCommand>(args[0], target, format, count);
}
UnknownCommand::~UnknownCommand() {
const size_t size = args_.length();
--- a/js/src/jit/mips-shared/Assembler-mips-shared.h
+++ b/js/src/jit/mips-shared/Assembler-mips-shared.h
@@ -1291,17 +1291,17 @@ class AssemblerMIPSShared : public Assem
writeRelocation(src);
}
void addLongJump(BufferOffset src, BufferOffset dst) {
CodeLabel cl;
cl.patchAt()->bind(src.getOffset());
cl.target()->bind(dst.getOffset());
cl.setLinkMode(CodeLabel::JumpImmediate);
- addCodeLabel(mozilla::Move(cl));
+ addCodeLabel(std::move(cl));
}
public:
void flushBuffer() {
}
void comment(const char* msg) {
spew("; %s", msg);
--- a/js/src/jit/shared/CodeGenerator-shared.cpp
+++ b/js/src/jit/shared/CodeGenerator-shared.cpp
@@ -987,17 +987,17 @@ struct ReadTempTypeInfoVectorOp : public
}
void operator()(JS::TrackedTypeSite site, MIRType mirType) override {
OptimizationTypeInfo ty(alloc_, site, mirType);
for (uint32_t i = 0; i < accTypes_.length(); i++) {
if (!ty.trackType(accTypes_[i]))
oom_ = true;
}
- if (!types_->append(mozilla::Move(ty)))
+ if (!types_->append(std::move(ty)))
oom_ = true;
accTypes_.clear();
}
};
#endif // DEBUG
void
CodeGeneratorShared::verifyCompactTrackedOptimizationsMap(JitCode* code, uint32_t numRegions,
@@ -1712,17 +1712,17 @@ CodeGeneratorShared::emitTracelogTree(bo
masm.branchTestPtr(Assembler::Zero, loggerReg, loggerReg, &done);
Address enabledAddress(loggerReg, TraceLoggerThread::offsetOfEnabled());
masm.branch32(Assembler::Equal, enabledAddress, Imm32(0), &done);
masm.Push(eventReg);
PatchableTLEvent patchEvent(masm.movWithPatch(ImmWord(0), eventReg), text);
- masm.propagateOOM(patchableTLEvents_.append(Move(patchEvent)));
+ masm.propagateOOM(patchableTLEvents_.append(std::move(patchEvent)));
if (isStart)
masm.tracelogStartId(loggerReg, eventReg);
else
masm.tracelogStopId(loggerReg, eventReg);
masm.Pop(eventReg);
--- a/js/src/jit/x86-shared/MacroAssembler-x86-shared.h
+++ b/js/src/jit/x86-shared/MacroAssembler-x86-shared.h
@@ -37,17 +37,17 @@ class MacroAssemblerX86Shared : public A
template<class T>
struct Constant {
typedef T Pod;
T value;
UsesVector uses;
explicit Constant(const T& value) : value(value) {}
- Constant(Constant<T>&& other) : value(other.value), uses(mozilla::Move(other.uses)) {}
+ Constant(Constant<T>&& other) : value(other.value), uses(std::move(other.uses)) {}
explicit Constant(const Constant<T>&) = delete;
};
// Containers use SystemAllocPolicy since wasm releases memory after each
// function is compiled, and these need to live until after all functions
// are compiled.
using Double = Constant<double>;
Vector<Double, 0, SystemAllocPolicy> doubles_;
@@ -56,17 +56,17 @@ class MacroAssemblerX86Shared : public A
using Float = Constant<float>;
Vector<Float, 0, SystemAllocPolicy> floats_;
typedef HashMap<float, size_t, DefaultHasher<float>, SystemAllocPolicy> FloatMap;
FloatMap floatMap_;
struct SimdData : public Constant<SimdConstant> {
explicit SimdData(SimdConstant d) : Constant<SimdConstant>(d) {}
- SimdData(SimdData&& d) : Constant<SimdConstant>(mozilla::Move(d)) {}
+ SimdData(SimdData&& d) : Constant<SimdConstant>(std::move(d)) {}
explicit SimdData(const SimdData&) = delete;
SimdConstant::Type type() const { return value.type(); }
};
Vector<SimdData, 0, SystemAllocPolicy> simds_;
typedef HashMap<SimdConstant, size_t, SimdConstant, SystemAllocPolicy> SimdMap;
SimdMap simdMap_;
--- a/js/src/jsapi-tests/testHashTable.cpp
+++ b/js/src/jsapi-tests/testHashTable.cpp
@@ -307,17 +307,17 @@ struct MoveOnlyType {
MoveOnlyType(MoveOnlyType&& rhs) {
val = rhs.val;
}
MoveOnlyType& operator=(MoveOnlyType&& rhs) {
MOZ_ASSERT(&rhs != this);
this->~MoveOnlyType();
- new(this) MoveOnlyType(mozilla::Move(rhs));
+ new(this) MoveOnlyType(std::move(rhs));
return *this;
}
struct HashPolicy {
typedef MoveOnlyType Lookup;
static js::HashNumber hash(const Lookup& lookup) {
return lookup.val;
@@ -337,17 +337,17 @@ BEGIN_TEST(testHashSetOfMoveOnlyType)
{
typedef js::HashSet<MoveOnlyType, MoveOnlyType::HashPolicy, js::SystemAllocPolicy> Set;
Set set;
CHECK(set.init());
MoveOnlyType a(1);
- CHECK(set.put(mozilla::Move(a))); // This shouldn't generate a compiler error.
+ CHECK(set.put(std::move(a))); // This shouldn't generate a compiler error.
return true;
}
END_TEST(testHashSetOfMoveOnlyType)
#if defined(DEBUG)
// Add entries to a HashMap using lookupWithDefault until either we get an OOM,
@@ -411,17 +411,17 @@ BEGIN_TEST(testHashTableMovableEnum)
CHECK(set.put(3));
CHECK(set.count() == 3);
{
auto e1 = IntSet::Enum(set);
CHECK(!e1.empty());
e1.removeFront();
e1.popFront();
- auto e2 = mozilla::Move(e1);
+ auto e2 = std::move(e1);
CHECK(!e2.empty());
e2.removeFront();
e2.popFront();
}
CHECK(set.count() == 1);
return true;
}
--- a/js/src/jsapi-tests/testSharedImmutableStringsCache.cpp
+++ b/js/src/jsapi-tests/testSharedImmutableStringsCache.cpp
@@ -38,17 +38,17 @@ static void
getString(CacheAndIndex* cacheAndIndex)
{
for (int i = 0; i < NUM_ITERATIONS; i++) {
auto str = STRINGS[cacheAndIndex->index % NUM_STRINGS];
auto dupe = js::DuplicateString(str);
MOZ_RELEASE_ASSERT(dupe);
- auto deduped = cacheAndIndex->cache->getOrCreate(mozilla::Move(dupe), js_strlen(str));
+ auto deduped = cacheAndIndex->cache->getOrCreate(std::move(dupe), js_strlen(str));
MOZ_RELEASE_ASSERT(deduped.isSome());
MOZ_RELEASE_ASSERT(js::EqualChars(str, deduped->chars(), js_strlen(str) + 1));
{
auto cloned = deduped->clone();
// We should be de-duplicating and giving back the same string.
MOZ_RELEASE_ASSERT(deduped->chars() == cloned.chars());
}
--- a/js/src/jsapi-tests/testThreadingThread.cpp
+++ b/js/src/jsapi-tests/testThreadingThread.cpp
@@ -28,17 +28,17 @@ BEGIN_TEST(testThreadingThreadJoin)
END_TEST(testThreadingThreadJoin)
BEGIN_TEST(testThreadingThreadDetach)
{
// We are going to detach this thread. Unlike join, we can't have it pointing at the stack
// because it might do the write after we have returned and pushed a new frame.
bool* flag = js_new<bool>(false);
js::Thread thread;
- CHECK(thread.init([](bool* flag){*flag = true; js_delete(flag);}, mozilla::Move(flag)));
+ CHECK(thread.init([](bool* flag){*flag = true; js_delete(flag);}, std::move(flag)));
CHECK(thread.joinable());
thread.detach();
CHECK(!thread.joinable());
return true;
}
END_TEST(testThreadingThreadDetach)
--- a/js/src/jsapi-tests/testUbiNode.cpp
+++ b/js/src/jsapi-tests/testUbiNode.cpp
@@ -696,17 +696,17 @@ BEGIN_TEST(test_JS_ubi_ShortestPaths_no_
{
JS::AutoCheckCannotGC noGC(cx);
JS::ubi::NodeSet targets;
CHECK(targets.init());
CHECK(targets.put(&b));
maybeShortestPaths = JS::ubi::ShortestPaths::Create(cx, noGC, 10, &a,
- mozilla::Move(targets));
+ std::move(targets));
}
CHECK(maybeShortestPaths);
auto& paths = *maybeShortestPaths;
size_t numPathsFound = 0;
bool ok = paths.forEachPath(&b, [&](JS::ubi::Path& path) {
numPathsFound++;
@@ -738,17 +738,17 @@ BEGIN_TEST(test_JS_ubi_ShortestPaths_one
{
JS::AutoCheckCannotGC noGC(cx);
JS::ubi::NodeSet targets;
CHECK(targets.init());
CHECK(targets.put(&b));
maybeShortestPaths = JS::ubi::ShortestPaths::Create(cx, noGC, 10, &a,
- mozilla::Move(targets));
+ std::move(targets));
}
CHECK(maybeShortestPaths);
auto& paths = *maybeShortestPaths;
size_t numPathsFound = 0;
bool ok = paths.forEachPath(&b, [&](JS::ubi::Path& path) {
numPathsFound++;
@@ -805,17 +805,17 @@ BEGIN_TEST(test_JS_ubi_ShortestPaths_mul
{
JS::AutoCheckCannotGC noGC(cx);
JS::ubi::NodeSet targets;
CHECK(targets.init());
CHECK(targets.put(&f));
maybeShortestPaths = JS::ubi::ShortestPaths::Create(cx, noGC, 10, &a,
- mozilla::Move(targets));
+ std::move(targets));
}
CHECK(maybeShortestPaths);
auto& paths = *maybeShortestPaths;
size_t numPathsFound = 0;
bool ok = paths.forEachPath(&f, [&](JS::ubi::Path& path) {
numPathsFound++;
@@ -897,17 +897,17 @@ BEGIN_TEST(test_JS_ubi_ShortestPaths_mor
{
JS::AutoCheckCannotGC noGC(cx);
JS::ubi::NodeSet targets;
CHECK(targets.init());
CHECK(targets.put(&f));
maybeShortestPaths = JS::ubi::ShortestPaths::Create(cx, noGC, 1, &a,
- mozilla::Move(targets));
+ std::move(targets));
}
CHECK(maybeShortestPaths);
auto& paths = *maybeShortestPaths;
size_t numPathsFound = 0;
bool ok = paths.forEachPath(&f, [&](JS::ubi::Path& path) {
numPathsFound++;
@@ -947,17 +947,17 @@ BEGIN_TEST(test_JS_ubi_ShortestPaths_mul
{
JS::AutoCheckCannotGC noGC(cx);
JS::ubi::NodeSet targets;
CHECK(targets.init());
CHECK(targets.put(&b));
maybeShortestPaths = JS::ubi::ShortestPaths::Create(cx, noGC, 10, &a,
- mozilla::Move(targets));
+ std::move(targets));
}
CHECK(maybeShortestPaths);
auto& paths = *maybeShortestPaths;
size_t numPathsFound = 0;
bool foundX = false;
bool foundY = false;
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -7099,17 +7099,17 @@ JSErrorNotes::addNoteASCII(JSContext* cx
va_list ap;
va_start(ap, errorNumber);
auto note = CreateErrorNoteVA(cx, filename, lineno, column, errorCallback, userRef,
errorNumber, ArgumentsAreASCII, ap);
va_end(ap);
if (!note)
return false;
- if (!notes_.append(Move(note)))
+ if (!notes_.append(std::move(note)))
return false;
return true;
}
bool
JSErrorNotes::addNoteLatin1(JSContext* cx,
const char* filename, unsigned lineno, unsigned column,
JSErrorCallback errorCallback, void* userRef,
@@ -7118,17 +7118,17 @@ JSErrorNotes::addNoteLatin1(JSContext* c
va_list ap;
va_start(ap, errorNumber);
auto note = CreateErrorNoteVA(cx, filename, lineno, column, errorCallback, userRef,
errorNumber, ArgumentsAreLatin1, ap);
va_end(ap);
if (!note)
return false;
- if (!notes_.append(Move(note)))
+ if (!notes_.append(std::move(note)))
return false;
return true;
}
bool
JSErrorNotes::addNoteUTF8(JSContext* cx,
const char* filename, unsigned lineno, unsigned column,
JSErrorCallback errorCallback, void* userRef,
@@ -7137,17 +7137,17 @@ JSErrorNotes::addNoteUTF8(JSContext* cx,
va_list ap;
va_start(ap, errorNumber);
auto note = CreateErrorNoteVA(cx, filename, lineno, column, errorCallback, userRef,
errorNumber, ArgumentsAreUTF8, ap);
va_end(ap);
if (!note)
return false;
- if (!notes_.append(Move(note)))
+ if (!notes_.append(std::move(note)))
return false;
return true;
}
JS_PUBLIC_API(size_t)
JSErrorNotes::length()
{
return notes_.length();
@@ -7162,17 +7162,17 @@ JSErrorNotes::copy(JSContext* cx)
return nullptr;
}
for (auto&& note : *this) {
js::UniquePtr<JSErrorNotes::Note> copied(CopyErrorNote(cx, note.get()));
if (!copied)
return nullptr;
- if (!copiedNotes->notes_.append(Move(copied)))
+ if (!copiedNotes->notes_.append(std::move(copied)))
return nullptr;
}
return copiedNotes;
}
JS_PUBLIC_API(JSErrorNotes::iterator)
JSErrorNotes::begin()
@@ -7484,17 +7484,17 @@ void AutoFilename::setUnowned(const char
{
MOZ_ASSERT(!get());
filename_.as<const char*>() = filename ? filename : "";
}
void AutoFilename::setOwned(UniqueChars&& filename)
{
MOZ_ASSERT(!get());
- filename_ = AsVariant(Move(filename));
+ filename_ = AsVariant(std::move(filename));
}
const char* AutoFilename::get() const
{
if (filename_.is<const char*>())
return filename_.as<const char*>();
return filename_.as<UniqueChars>().get();
}
@@ -7524,17 +7524,17 @@ DescribeScriptedCaller(JSContext* cx, Au
if (filename) {
if (i.isWasm()) {
// For Wasm, copy out the filename, there is no script source.
UniqueChars copy = DuplicateString(i.filename() ? i.filename() : "");
if (!copy)
filename->setUnowned("out of memory");
else
- filename->setOwned(Move(copy));
+ filename->setOwned(std::move(copy));
} else {
// All other frames have a script source to read the filename from.
filename->setScriptSource(i.scriptSource());
}
}
if (lineno)
*lineno = i.computeLine(column);
@@ -7779,25 +7779,25 @@ JS::GetWasmModule(HandleObject obj)
{
MOZ_ASSERT(JS::IsWasmModuleObject(obj));
return &CheckedUnwrap(obj)->as<WasmModuleObject>().module();
}
JS_PUBLIC_API(bool)
JS::CompiledWasmModuleAssumptionsMatch(PRFileDesc* compiled, JS::BuildIdCharVector&& buildId)
{
- return wasm::CompiledModuleAssumptionsMatch(compiled, Move(buildId));
+ return wasm::CompiledModuleAssumptionsMatch(compiled, std::move(buildId));
}
JS_PUBLIC_API(RefPtr<JS::WasmModule>)
JS::DeserializeWasmModule(PRFileDesc* bytecode, PRFileDesc* maybeCompiled,
JS::BuildIdCharVector&& buildId, UniqueChars file,
unsigned line)
{
- return wasm::DeserializeModule(bytecode, maybeCompiled, Move(buildId), Move(file), line);
+ return wasm::DeserializeModule(bytecode, maybeCompiled, std::move(buildId), std::move(file), line);
}
JS_PUBLIC_API(void)
JS::SetProcessLargeAllocationFailureCallback(JS::LargeAllocationFailureCallback lafc)
{
MOZ_ASSERT(!OnLargeAllocationFailure);
OnLargeAllocationFailure = lafc;
}
@@ -7819,17 +7819,17 @@ JS::CaptureCurrentStack(JSContext* cx, J
JS::StackCapture&& capture /* = JS::StackCapture(JS::AllFrames()) */)
{
AssertHeapIsIdle();
CHECK_REQUEST(cx);
MOZ_RELEASE_ASSERT(cx->realm());
Realm* realm = cx->realm();
Rooted<SavedFrame*> frame(cx);
- if (!realm->savedStacks().saveCurrentStack(cx, &frame, mozilla::Move(capture)))
+ if (!realm->savedStacks().saveCurrentStack(cx, &frame, std::move(capture)))
return false;
stackp.set(frame.get());
return true;
}
JS_PUBLIC_API(bool)
JS::CopyAsyncStack(JSContext* cx, JS::HandleObject asyncStack,
JS::HandleString asyncCause, JS::MutableHandleObject stackp,
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -6243,17 +6243,17 @@ struct JS_PUBLIC_API(FirstSubsumedFrame)
: principals(rhs.principals)
, ignoreSelfHosted(rhs.ignoreSelfHosted)
{
MOZ_ASSERT(this != &rhs, "self move disallowed");
rhs.principals = nullptr;
}
FirstSubsumedFrame& operator=(FirstSubsumedFrame&& rhs) {
- new (this) FirstSubsumedFrame(mozilla::Move(rhs));
+ new (this) FirstSubsumedFrame(std::move(rhs));
return *this;
}
~FirstSubsumedFrame() {
if (principals)
JS_DropPrincipals(cx, principals);
}
};
--- a/js/src/jsexn.cpp
+++ b/js/src/jsexn.cpp
@@ -247,17 +247,17 @@ CopyExtraData(JSContext* cx, uint8_t** c
/* Note that this is before it gets flagged with JSREPORT_EXCEPTION */
copy->flags = report->flags;
/* Deep copy notes. */
if (report->notes) {
auto copiedNotes = report->notes->copy(cx);
if (!copiedNotes)
return false;
- copy->notes = Move(copiedNotes);
+ copy->notes = std::move(copiedNotes);
} else {
copy->notes.reset(nullptr);
}
return true;
}
bool
--- a/js/src/jsfriendapi.cpp
+++ b/js/src/jsfriendapi.cpp
@@ -52,23 +52,23 @@ JS::RootingContext::RootingContext()
for (int i=0; i<StackKindCount; i++)
nativeStackLimit[i] = UINTPTR_MAX;
#endif
}
JS_FRIEND_API(void)
js::SetSourceHook(JSContext* cx, mozilla::UniquePtr<SourceHook> hook)
{
- cx->runtime()->sourceHook.ref() = Move(hook);
+ cx->runtime()->sourceHook.ref() = std::move(hook);
}
JS_FRIEND_API(mozilla::UniquePtr<SourceHook>)
js::ForgetSourceHook(JSContext* cx)
{
- return Move(cx->runtime()->sourceHook.ref());
+ return std::move(cx->runtime()->sourceHook.ref());
}
JS_FRIEND_API(void)
JS_SetGrayGCRootsTracer(JSContext* cx, JSTraceDataOp traceOp, void* data)
{
cx->runtime()->gc.setGrayRootsTracer(traceOp, data);
}
@@ -835,17 +835,17 @@ FormatValue(JSContext* cx, const Value&
// context.
static JS::UniqueChars
MOZ_FORMAT_PRINTF(3, 4)
sprintf_append(JSContext* cx, JS::UniqueChars&& buf, const char* fmt, ...)
{
va_list ap;
va_start(ap, fmt);
- JS::UniqueChars result = JS_vsprintf_append(Move(buf), fmt, ap);
+ JS::UniqueChars result = JS_vsprintf_append(std::move(buf), fmt, ap);
va_end(ap);
if (!result) {
ReportOutOfMemory(cx);
return nullptr;
}
return result;
@@ -875,27 +875,27 @@ FormatFrame(JSContext* cx, const FrameIt
fun && !fun->isArrow() && !fun->isDerivedClassConstructor() &&
!(fun->isBoundFunction() && iter.isConstructing()))
{
if (!GetFunctionThis(cx, iter.abstractFramePtr(), &thisVal))
return nullptr;
}
// print the frame number and function name
- JS::UniqueChars buf(Move(inBuf));
+ JS::UniqueChars buf(std::move(inBuf));
if (funname) {
JSAutoByteString funbytes;
char* str = funbytes.encodeLatin1(cx, funname);
if (!str)
return nullptr;
- buf = sprintf_append(cx, Move(buf), "%d %s(", num, str);
+ buf = sprintf_append(cx, std::move(buf), "%d %s(", num, str);
} else if (fun) {
- buf = sprintf_append(cx, Move(buf), "%d anonymous(", num);
+ buf = sprintf_append(cx, std::move(buf), "%d anonymous(", num);
} else {
- buf = sprintf_append(cx, Move(buf), "%d <TOP LEVEL>", num);
+ buf = sprintf_append(cx, std::move(buf), "%d <TOP LEVEL>", num);
}
if (!buf)
return nullptr;
if (showArgs && iter.hasArgs()) {
PositionalFormalParameterIter fi(script);
bool first = true;
for (unsigned i = 0; i < iter.numActualArgs(); i++) {
@@ -934,39 +934,39 @@ FormatFrame(JSContext* cx, const FrameIt
return nullptr;
} else {
name = "(destructured parameter)";
}
fi++;
}
if (value) {
- buf = sprintf_append(cx, Move(buf), "%s%s%s%s%s%s",
+ buf = sprintf_append(cx, std::move(buf), "%s%s%s%s%s%s",
!first ? ", " : "",
name ? name :"",
name ? " = " : "",
arg.isString() ? "\"" : "",
value,
arg.isString() ? "\"" : "");
if (!buf)
return nullptr;
first = false;
} else {
- buf = sprintf_append(cx, Move(buf),
+ buf = sprintf_append(cx, std::move(buf),
" <Failed to get argument while inspecting stack frame>\n");
if (!buf)
return nullptr;
}
}
}
// print filename and line number
- buf = sprintf_append(cx, Move(buf), "%s [\"%s\":%d]\n",
+ buf = sprintf_append(cx, std::move(buf), "%s [\"%s\":%d]\n",
fun ? ")" : "",
filename ? filename : "<unknown>",
lineno);
if (!buf)
return nullptr;
// Note: Right now we don't dump the local variables anymore, because
@@ -981,19 +981,19 @@ FormatFrame(JSContext* cx, const FrameIt
if (cx->isThrowingOutOfMemory())
return nullptr;
cx->clearPendingException();
}
if (thisValStr) {
const char* str = thisValBytes.encodeLatin1(cx, thisValStr);
if (!str)
return nullptr;
- buf = sprintf_append(cx, Move(buf), " this = %s\n", str);
+ buf = sprintf_append(cx, std::move(buf), " this = %s\n", str);
} else {
- buf = sprintf_append(cx, Move(buf), " <failed to get 'this' value>\n");
+ buf = sprintf_append(cx, std::move(buf), " <failed to get 'this' value>\n");
}
if (!buf)
return nullptr;
}
}
if (showThisProps && thisVal.isObject()) {
RootedObject obj(cx, &thisVal.toObject());
@@ -1010,17 +1010,17 @@ FormatFrame(JSContext* cx, const FrameIt
RootedId id(cx, keys[i]);
RootedValue key(cx, IdToValue(id));
RootedValue v(cx);
if (!GetProperty(cx, obj, obj, id, &v)) {
if (cx->isThrowingOutOfMemory())
return nullptr;
cx->clearPendingException();
- buf = sprintf_append(cx, Move(buf),
+ buf = sprintf_append(cx, std::move(buf),
" <Failed to fetch property while inspecting stack frame>\n");
if (!buf)
return nullptr;
continue;
}
JSAutoByteString nameBytes;
const char* name = FormatValue(cx, key, nameBytes);
@@ -1034,23 +1034,23 @@ FormatFrame(JSContext* cx, const FrameIt
const char* value = FormatValue(cx, v, valueBytes);
if (!value) {
if (cx->isThrowingOutOfMemory())
return nullptr;
cx->clearPendingException();
}
if (name && value) {
- buf = sprintf_append(cx, Move(buf), " this.%s = %s%s%s\n",
+ buf = sprintf_append(cx, std::move(buf), " this.%s = %s%s%s\n",
name,
v.isString() ? "\"" : "",
value,
v.isString() ? "\"" : "");
} else {
- buf = sprintf_append(cx, Move(buf),
+ buf = sprintf_append(cx, std::move(buf),
" <Failed to format values while inspecting stack frame>\n");
}
if (!buf)
return nullptr;
}
}
MOZ_ASSERT(!cx->isExceptionPending());
@@ -1062,52 +1062,52 @@ FormatWasmFrame(JSContext* cx, const Fra
{
UniqueChars nameStr;
if (JSAtom* functionDisplayAtom = iter.maybeFunctionDisplayAtom()) {
nameStr = StringToNewUTF8CharsZ(cx, *functionDisplayAtom);
if (!nameStr)
return nullptr;
}
- JS::UniqueChars buf = sprintf_append(cx, Move(inBuf), "%d %s()",
+ JS::UniqueChars buf = sprintf_append(cx, std::move(inBuf), "%d %s()",
num,
nameStr ? nameStr.get() : "<wasm-function>");
if (!buf)
return nullptr;
- buf = sprintf_append(cx, Move(buf), " [\"%s\":wasm-function[%d]:0x%x]\n",
+ buf = sprintf_append(cx, std::move(buf), " [\"%s\":wasm-function[%d]:0x%x]\n",
iter.filename() ? iter.filename() : "<unknown>",
iter.wasmFuncIndex(),
iter.wasmBytecodeOffset());
if (!buf)
return nullptr;
MOZ_ASSERT(!cx->isExceptionPending());
return buf;
}
JS_FRIEND_API(JS::UniqueChars)
JS::FormatStackDump(JSContext* cx, JS::UniqueChars&& inBuf, bool showArgs, bool showLocals,
bool showThisProps)
{
int num = 0;
- JS::UniqueChars buf(Move(inBuf));
+ JS::UniqueChars buf(std::move(inBuf));
for (AllFramesIter i(cx); !i.done(); ++i) {
if (i.hasScript())
- buf = FormatFrame(cx, i, Move(buf), num, showArgs, showLocals, showThisProps);
+ buf = FormatFrame(cx, i, std::move(buf), num, showArgs, showLocals, showThisProps);
else
- buf = FormatWasmFrame(cx, i, Move(buf), num);
+ buf = FormatWasmFrame(cx, i, std::move(buf), num);
if (!buf)
return nullptr;
num++;
}
if (!num)
- buf = JS_sprintf_append(Move(buf), "JavaScript stack is empty\n");
+ buf = JS_sprintf_append(std::move(buf), "JavaScript stack is empty\n");
return buf;
}
extern JS_FRIEND_API(bool)
JS::ForceLexicalInitialization(JSContext *cx, HandleObject obj)
{
AssertHeapIsIdle();
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -277,17 +277,17 @@ class js::shell::OffThreadJob {
JS::OffThreadToken* token;
Source source;
};
static OffThreadJob*
NewOffThreadJob(JSContext* cx, ScriptKind kind, OffThreadJob::Source&& source)
{
ShellContext* sc = GetShellContext(cx);
- UniquePtr<OffThreadJob> job(cx->new_<OffThreadJob>(sc, kind, Move(source)));
+ UniquePtr<OffThreadJob> job(cx->new_<OffThreadJob>(sc, kind, std::move(source)));
if (!job)
return nullptr;
if (!sc->offThreadJobs.append(job.get())) {
job->cancel();
JS_ReportErrorASCII(cx, "OOM adding off-thread job");
return nullptr;
}
@@ -417,17 +417,17 @@ CancelOffThreadJobsForRuntime(JSContext*
mozilla::Atomic<int32_t> gOffThreadJobSerial(1);
OffThreadJob::OffThreadJob(ShellContext* sc, ScriptKind kind, Source&& source)
: id(gOffThreadJobSerial++),
kind(kind),
monitor(sc->offThreadMonitor),
state(RUNNING),
token(nullptr),
- source(Move(source))
+ source(std::move(source))
{
MOZ_RELEASE_ASSERT(id > 0, "Off-thread job IDs exhausted");
}
OffThreadJob::~OffThreadJob()
{
MOZ_ASSERT(state != RUNNING);
}
@@ -1495,29 +1495,29 @@ Options(JSContext* cx, unsigned argc, Va
opt.ptr());
return false;
}
}
UniqueChars names = DuplicateString("");
bool found = false;
if (names && oldContextOptions.extraWarnings()) {
- names = JS_sprintf_append(Move(names), "%s%s", found ? "," : "", "strict");
+ names = JS_sprintf_append(std::move(names), "%s%s", found ? "," : "", "strict");
found = true;
}
if (names && oldContextOptions.werror()) {
- names = JS_sprintf_append(Move(names), "%s%s", found ? "," : "", "werror");
+ names = JS_sprintf_append(std::move(names), "%s%s", found ? "," : "", "werror");
found = true;
}
if (names && oldContextOptions.throwOnAsmJSValidationFailure()) {
- names = JS_sprintf_append(Move(names), "%s%s", found ? "," : "", "throw_on_asmjs_validation_failure");
+ names = JS_sprintf_append(std::move(names), "%s%s", found ? "," : "", "throw_on_asmjs_validation_failure");
found = true;
}
if (names && oldContextOptions.strictMode()) {
- names = JS_sprintf_append(Move(names), "%s%s", found ? "," : "", "strict_mode");
+ names = JS_sprintf_append(std::move(names), "%s%s", found ? "," : "", "strict_mode");
found = true;
}
if (!names) {
JS_ReportOutOfMemory(cx);
return false;
}
JSString* str = JS_NewStringCopyZ(cx, names.get());
@@ -4699,17 +4699,17 @@ OffThreadCompileScript(JSContext* cx, un
}
if (!JS::CanCompileOffThread(cx, options, length)) {
JS_ReportErrorASCII(cx, "cannot compile code on worker thread");
return false;
}
OffThreadJob* job = NewOffThreadJob(cx, ScriptKind::Script,
- OffThreadJob::Source(Move(ownedChars)));
+ OffThreadJob::Source(std::move(ownedChars)));
if (!job)
return false;
if (!JS::CompileOffThread(cx, options, job->sourceChars(), length,
OffThreadCompileScriptCallback, job))
{
job->cancel();
DeleteOffThreadJob(cx, job);
@@ -4785,17 +4785,17 @@ OffThreadCompileModule(JSContext* cx, un
}
if (!JS::CanCompileOffThread(cx, options, length)) {
JS_ReportErrorASCII(cx, "cannot compile code on worker thread");
return false;
}
OffThreadJob* job = NewOffThreadJob(cx, ScriptKind::Module,
- OffThreadJob::Source(Move(ownedChars)));
+ OffThreadJob::Source(std::move(ownedChars)));
if (!job)
return false;
if (!JS::CompileOffThreadModule(cx, options, job->sourceChars(), length,
OffThreadCompileScriptCallback, job))
{
job->cancel();
DeleteOffThreadJob(cx, job);
@@ -4890,17 +4890,17 @@ OffThreadDecodeScript(JSContext* cx, uns
}
if (!JS::CanDecodeOffThread(cx, options, loadLength)) {
JS_ReportErrorASCII(cx, "cannot compile code on worker thread");
return false;
}
OffThreadJob* job = NewOffThreadJob(cx, ScriptKind::DecodeScript,
- OffThreadJob::Source(Move(loadBuffer)));
+ OffThreadJob::Source(std::move(loadBuffer)));
if (!job)
return false;
if (!JS::DecodeOffThreadScript(cx, options, job->xdrBuffer(), 0,
OffThreadCompileScriptCallback, job))
{
job->cancel();
DeleteOffThreadJob(cx, job);
@@ -5439,21 +5439,21 @@ WithSourceHook(JSContext* cx, unsigned a
}
mozilla::UniquePtr<ShellSourceHook> hook =
mozilla::MakeUnique<ShellSourceHook>(cx, args[0].toObject().as<JSFunction>());
if (!hook)
return false;
mozilla::UniquePtr<SourceHook> savedHook = js::ForgetSourceHook(cx);
- js::SetSourceHook(cx, Move(hook));
+ js::SetSourceHook(cx, std::move(hook));
RootedObject fun(cx, &args[1].toObject());
bool result = Call(cx, UndefinedHandleValue, fun, JS::HandleValueArray::empty(), args.rval());
- js::SetSourceHook(cx, Move(savedHook));
+ js::SetSourceHook(cx, std::move(savedHook));
return result;
}
static bool
IsCachingEnabled(JSContext* cx, unsigned argc, Value* vp)
{
CallArgs args = CallArgsFromVp(argc, vp);
args.rval().setBoolean(jsCachingEnabled && jsCacheAsmJSPath != nullptr);
@@ -5537,17 +5537,17 @@ SingleStepCallback(void* arg, jit::Simul
ShellContext* sc = GetShellContext(cx);
// Only append the stack if it differs from the last stack.
if (sc->stacks.empty() ||
sc->stacks.back().length() != stack.length() ||
!PodEqual(sc->stacks.back().begin(), stack.begin(), stack.length()))
{
- if (!sc->stacks.append(Move(stack)))
+ if (!sc->stacks.append(std::move(stack)))
oomUnsafe.crash("stacks.append");
}
}
#endif
static bool
EnableSingleStepProfiling(JSContext* cx, unsigned argc, Value* vp)
{
@@ -5948,17 +5948,17 @@ ConsumeBufferSource(JSContext* cx, JS::H
memcpy(job->bytes.begin(), dataPointer.unwrap(), byteLength);
BufferStreamJob* jobPtr = job.get();
{
auto state = bufferStreamState->lock();
MOZ_ASSERT(!state->shutdown);
- if (!state->jobs.append(Move(job)))
+ if (!state->jobs.append(std::move(job)))
return false;
}
return jobPtr->thread.init(BufferStreamMain, jobPtr);
}
static bool
SetBufferStreamParams(JSContext* cx, unsigned argc, Value* vp)
@@ -6470,30 +6470,30 @@ class ShellAutoEntryMonitor : JS::dbg::A
if (displayId) {
UniqueChars displayIdStr(JS_EncodeStringToUTF8(cx, displayId));
if (!displayIdStr) {
// We report OOM in buildResult.
cx->recoverFromOutOfMemory();
oom = true;
return;
}
- oom = !log.append(mozilla::Move(displayIdStr));
+ oom = !log.append(std::move(displayIdStr));
return;
}
oom = !log.append(DuplicateString("anonymous"));
}
void Entry(JSContext* cx, JSScript* script, JS::HandleValue asyncStack,
const char* asyncCause) override {
MOZ_ASSERT(!enteredWithoutExit);
enteredWithoutExit = true;
UniqueChars label(JS_smprintf("eval:%s", JS_GetScriptFilename(script)));
- oom = !label || !log.append(mozilla::Move(label));
+ oom = !label || !log.append(std::move(label));
}
void Exit(JSContext* cx) override {
MOZ_ASSERT(enteredWithoutExit);
enteredWithoutExit = false;
}
bool buildResult(JSContext *cx, MutableHandleValue resultValue) {
--- a/js/src/threading/ConditionVariable.h
+++ b/js/src/threading/ConditionVariable.h
@@ -105,17 +105,17 @@ public:
// As with |wait_for|, block the current thread of execution until woken from
// another thread or the given time duration has elapsed. This method will
// resume waiting once woken until the given Predicate |pred| evaluates to
// true.
template <typename Predicate>
bool wait_for(UniqueLock<Mutex>& lock, const mozilla::TimeDuration& rel_time,
Predicate pred) {
return wait_until(lock, mozilla::TimeStamp::Now() + rel_time,
- mozilla::Move(pred));
+ std::move(pred));
}
private:
ConditionVariable(const ConditionVariable&) = delete;
ConditionVariable& operator=(const ConditionVariable&) = delete;
template <class T> friend class ExclusiveWaitableData;
--- a/js/src/threading/ExclusiveData.h
+++ b/js/src/threading/ExclusiveData.h
@@ -107,25 +107,25 @@ class ExclusiveData
*/
template <typename... Args>
explicit ExclusiveData(const MutexId& id, Args&&... args)
: lock_(id),
value_(mozilla::Forward<Args>(args)...)
{}
ExclusiveData(ExclusiveData&& rhs)
- : lock_(mozilla::Move(rhs.lock)),
- value_(Move(rhs.value_))
+ : lock_(std::move(rhs.lock)),
+ value_(std::move(rhs.value_))
{
MOZ_ASSERT(&rhs != this, "self-move disallowed!");
}
ExclusiveData& operator=(ExclusiveData&& rhs) {
this->~ExclusiveData();
- new (mozilla::KnownNotNull, this) ExclusiveData(mozilla::Move(rhs));
+ new (mozilla::KnownNotNull, this) ExclusiveData(std::move(rhs));
return *this;
}
/**
* An RAII class that provides exclusive access to a `ExclusiveData<T>`'s
* protected inner `T` value.
*
* Note that this is intentionally marked MOZ_STACK_CLASS instead of
@@ -150,17 +150,17 @@ class ExclusiveData
: parent_(rhs.parent_)
{
MOZ_ASSERT(&rhs != this, "self-move disallowed!");
rhs.parent_ = nullptr;
}
Guard& operator=(Guard&& rhs) {
this->~Guard();
- new (this) Guard(mozilla::Move(rhs));
+ new (this) Guard(std::move(rhs));
return *this;
}
T& get() const {
MOZ_ASSERT(parent_);
return parent_->value_;
}
@@ -209,21 +209,21 @@ class ExclusiveWaitableData : public Exc
typedef typename ExclusiveData<T>::Guard Base;
public:
explicit Guard(const ExclusiveWaitableData& parent)
: Base(parent)
{}
Guard(Guard&& guard)
- : Base(mozilla::Move(guard))
+ : Base(std::move(guard))
{}
Guard& operator=(Guard&& rhs) {
- return Base::operator=(mozilla::Move(rhs));
+ return Base::operator=(std::move(rhs));
}
void wait() {
auto* parent = static_cast<const ExclusiveWaitableData*>(this->parent());
parent->condVar_.impl_.wait(parent->lock_);
}
void notify_one() {
--- a/js/src/threading/Thread.h
+++ b/js/src/threading/Thread.h
@@ -104,17 +104,17 @@ public:
, options_(mozilla::Forward<O>(options))
{
MOZ_ASSERT(js::IsInitialized());
}
// Start a thread of execution at functor |f| with parameters |args|. This
// method will return false if thread creation fails. This Thread must not
// already have been created. Note that the arguments must be either POD or
- // rvalue references (mozilla::Move). Attempting to pass a reference will
+ // rvalue references (std::move). Attempting to pass a reference will
// result in the value being copied, which may not be the intended behavior.
// See the comment below on ThreadTrampoline::args for an explanation.
template <typename F, typename... Args>
MOZ_MUST_USE bool init(F&& f, Args&&... args) {
MOZ_RELEASE_ASSERT(id_ == Id());
using Trampoline = detail::ThreadTrampoline<F, Args...>;
AutoEnterOOMUnsafeRegion oom;
auto trampoline = js_new<Trampoline>(mozilla::Forward<F>(f),
--- a/js/src/util/Printf.cpp
+++ b/js/src/util/Printf.cpp
@@ -30,25 +30,25 @@ JS_PUBLIC_API(JS::UniqueChars) JS_smprin
}
JS_PUBLIC_API(JS::UniqueChars) JS_sprintf_append(JS::UniqueChars&& last, const char* fmt, ...)
{
va_list ap;
va_start(ap, fmt);
JSSmprintfPointer lastPtr(last.release());
JSSmprintfPointer result =
- mozilla::VsmprintfAppend<js::SystemAllocPolicy>(Move(lastPtr), fmt, ap);
+ mozilla::VsmprintfAppend<js::SystemAllocPolicy>(std::move(lastPtr), fmt, ap);
va_end(ap);
return JS::UniqueChars(result.release());
}
JS_PUBLIC_API(JS::UniqueChars) JS_vsmprintf(const char* fmt, va_list ap)
{
return JS::UniqueChars(mozilla::Vsmprintf<js::SystemAllocPolicy>(fmt, ap).release());
}
JS_PUBLIC_API(JS::UniqueChars) JS_vsprintf_append(JS::UniqueChars&& last,
const char* fmt, va_list ap)
{
JSSmprintfPointer lastPtr(last.release());
- return JS::UniqueChars(mozilla::VsmprintfAppend<js::SystemAllocPolicy>(Move(lastPtr),
+ return JS::UniqueChars(mozilla::VsmprintfAppend<js::SystemAllocPolicy>(std::move(lastPtr),
fmt, ap).release());
}
--- a/js/src/util/StringBuffer.cpp
+++ b/js/src/util/StringBuffer.cpp
@@ -62,17 +62,17 @@ StringBuffer::inflateChars()
*/
size_t capacity = Max(reserved_, latin1Chars().length());
if (!twoByte.reserve(capacity))
return false;
twoByte.infallibleAppend(latin1Chars().begin(), latin1Chars().length());
cb.destroy();
- cb.construct<TwoByteCharBuffer>(Move(twoByte));
+ cb.construct<TwoByteCharBuffer>(std::move(twoByte));
return true;
}
template <typename CharT, class Buffer>
static JSFlatString*
FinishStringFlat(JSContext* cx, StringBuffer& sb, Buffer& cb)
{
size_t len = sb.length();
--- a/js/src/vm/BytecodeUtil.cpp
+++ b/js/src/vm/BytecodeUtil.cpp
@@ -1139,27 +1139,27 @@ ToDisassemblySource(JSContext* cx, Handl
char* nbytes = QuoteString(&sprinter, v.toString(), '"');
if (!nbytes)
return false;
UniqueChars copy = JS_smprintf("%s", nbytes);
if (!copy) {
ReportOutOfMemory(cx);
return false;
}
- bytes->initBytes(Move(copy));
+ bytes->initBytes(std::move(copy));
return true;
}
if (JS::CurrentThreadIsHeapBusy() || !cx->isAllocAllowed()) {
UniqueChars source = JS_smprintf("<value>");
if (!source) {
ReportOutOfMemory(cx);
return false;
}
- bytes->initBytes(Move(source));
+ bytes->initBytes(std::move(source));
return true;
}
if (v.isObject()) {
JSObject& obj = v.toObject();
if (obj.is<JSFunction>()) {
RootedFunction fun(cx, &obj.as<JSFunction>());
@@ -1189,70 +1189,70 @@ ToDisassemblySource(JSContext* cx, Handl
return false;
}
for (Rooted<BindingIter> bi(cx, BindingIter(scope)); bi; bi++) {
JSAutoByteString nameBytes;
if (!AtomToPrintableString(cx, bi.name(), &nameBytes))
return false;
- source = JS_sprintf_append(Move(source), "%s: ", nameBytes.ptr());
+ source = JS_sprintf_append(std::move(source), "%s: ", nameBytes.ptr());
if (!source) {
ReportOutOfMemory(cx);
return false;
}
BindingLocation loc = bi.location();
switch (loc.kind()) {
case BindingLocation::Kind::Global:
- source = JS_sprintf_append(Move(source), "global");
+ source = JS_sprintf_append(std::move(source), "global");
break;
case BindingLocation::Kind::Frame:
- source = JS_sprintf_append(Move(source), "frame slot %u", loc.slot());
+ source = JS_sprintf_append(std::move(source), "frame slot %u", loc.slot());
break;
case BindingLocation::Kind::Environment:
- source = JS_sprintf_append(Move(source), "env slot %u", loc.slot());
+ source = JS_sprintf_append(std::move(source), "env slot %u", loc.slot());
break;
case BindingLocation::Kind::Argument:
- source = JS_sprintf_append(Move(source), "arg slot %u", loc.slot());
+ source = JS_sprintf_append(std::move(source), "arg slot %u", loc.slot());
break;
case BindingLocation::Kind::NamedLambdaCallee:
- source = JS_sprintf_append(Move(source), "named lambda callee");
+ source = JS_sprintf_append(std::move(source), "named lambda callee");
break;
case BindingLocation::Kind::Import:
- source = JS_sprintf_append(Move(source), "import");
+ source = JS_sprintf_append(std::move(source), "import");
break;
}
if (!source) {
ReportOutOfMemory(cx);
return false;
}
if (!bi.isLast()) {
- source = JS_sprintf_append(Move(source), ", ");
+ source = JS_sprintf_append(std::move(source), ", ");
if (!source) {
ReportOutOfMemory(cx);
return false;
}
}
}
- source = JS_sprintf_append(Move(source), "}");
+ source = JS_sprintf_append(std::move(source), "}");
if (!source) {
ReportOutOfMemory(cx);
return false;
}
- bytes->initBytes(Move(source));
+ bytes->initBytes(std::move(source));
return true;
}
static bool
DumpJumpOrigins(HandleScript script, jsbytecode* pc, BytecodeParser* parser, Sprinter* sp)
{
bool called = false;
auto callback = [&script, &sp, &called](jsbytecode* pc, BytecodeParser::JumpKind kind) {
--- a/js/src/vm/Caches.cpp
+++ b/js/src/vm/Caches.cpp
@@ -18,17 +18,17 @@ RuntimeCaches::createMathCache(JSContext
MOZ_ASSERT(!mathCache_);
UniquePtr<MathCache> newMathCache(js_new<MathCache>());
if (!newMathCache) {
ReportOutOfMemory(cx);
return nullptr;
}
- mathCache_ = Move(newMathCache);
+ mathCache_ = std::move(newMathCache);
return mathCache_.get();
}
bool
RuntimeCaches::init()
{
if (!evalCache.init())
return false;
--- a/js/src/vm/CodeCoverage.cpp
+++ b/js/src/vm/CodeCoverage.cpp
@@ -83,17 +83,17 @@ LCovSource::LCovSource(LCovSource&& src)
: name_(src.name_),
outFN_(src.outFN_),
outFNDA_(src.outFNDA_),
numFunctionsFound_(src.numFunctionsFound_),
numFunctionsHit_(src.numFunctionsHit_),
outBRDA_(src.outBRDA_),
numBranchesFound_(src.numBranchesFound_),
numBranchesHit_(src.numBranchesHit_),
- linesHit_(Move(src.linesHit_)),
+ linesHit_(std::move(src.linesHit_)),
numLinesInstrumented_(src.numLinesInstrumented_),
numLinesHit_(src.numLinesHit_),
maxLineHit_(src.maxLineHit_),
hasTopLevelScript_(src.hasTopLevelScript_)
{
src.name_ = nullptr;
}
@@ -511,17 +511,17 @@ LCovRealm::lookupOrAdd(JS::Realm* realm,
char* source_name = js_strdup(name);
if (!source_name) {
outTN_.reportOutOfMemory();
return nullptr;
}
// Allocate a new LCovSource for the current top-level.
- if (!sources_->append(Move(LCovSource(&alloc_, source_name)))) {
+ if (!sources_->append(std::move(LCovSource(&alloc_, source_name)))) {
outTN_.reportOutOfMemory();
return nullptr;
}
return &sources_->back();
}
void
--- a/js/src/vm/EnvironmentObject.cpp
+++ b/js/src/vm/EnvironmentObject.cpp
@@ -2523,17 +2523,17 @@ DebugEnvironments::ensureRealmData(JSCon
return debugEnvs;
auto debugEnvs = cx->make_unique<DebugEnvironments>(cx, cx->zone());
if (!debugEnvs || !debugEnvs->init()) {
ReportOutOfMemory(cx);
return nullptr;
}
- realm->debugEnvsRef() = Move(debugEnvs);
+ realm->debugEnvsRef() = std::move(debugEnvs);
return realm->debugEnvs();
}
/* static */ DebugEnvironmentProxy*
DebugEnvironments::hasDebugEnvironment(JSContext* cx, EnvironmentObject& env)
{
DebugEnvironments* envs = env.realm()->debugEnvs();
if (!envs)
--- a/js/src/vm/ErrorReporting.cpp
+++ b/js/src/vm/ErrorReporting.cpp
@@ -62,26 +62,26 @@ js::ReportCompileWarning(JSContext* cx,
// On the main thread, report the error immediately. When compiling off
// thread, save the error so that the thread finishing the parse can report
// it later.
CompileError tempErr;
CompileError* err = &tempErr;
if (cx->helperThread() && !cx->addPendingCompileError(&err))
return false;
- err->notes = Move(notes);
+ err->notes = std::move(notes);
err->flags = flags;
err->errorNumber = errorNumber;
err->filename = metadata.filename;
err->lineno = metadata.lineNumber;
err->column = metadata.columnNumber;
err->isMuted = metadata.isMuted;
- if (UniqueTwoByteChars lineOfContext = Move(metadata.lineOfContext))
+ if (UniqueTwoByteChars lineOfContext = std::move(metadata.lineOfContext))
err->initOwnedLinebuf(lineOfContext.release(), metadata.lineLength, metadata.tokenOffset);
if (!ExpandErrorArgumentsVA(cx, GetErrorMessage, nullptr, errorNumber,
nullptr, ArgumentsAreLatin1, err, args))
{
return false;
}
@@ -98,26 +98,26 @@ js::ReportCompileError(JSContext* cx, Er
// On the main thread, report the error immediately. When compiling off
// thread, save the error so that the thread finishing the parse can report
// it later.
CompileError tempErr;
CompileError* err = &tempErr;
if (cx->helperThread() && !cx->addPendingCompileError(&err))
return;
- err->notes = Move(notes);
+ err->notes = std::move(notes);
err->flags = flags;
err->errorNumber = errorNumber;
err->filename = metadata.filename;
err->lineno = metadata.lineNumber;
err->column = metadata.columnNumber;
err->isMuted = metadata.isMuted;
- if (UniqueTwoByteChars lineOfContext = Move(metadata.lineOfContext))
+ if (UniqueTwoByteChars lineOfContext = std::move(metadata.lineOfContext))
err->initOwnedLinebuf(lineOfContext.release(), metadata.lineLength, metadata.tokenOffset);
if (!ExpandErrorArgumentsVA(cx, GetErrorMessage, nullptr, errorNumber,
nullptr, ArgumentsAreLatin1, err, args))
{
return;
}
--- a/js/src/vm/GeckoProfiler.cpp
+++ b/js/src/vm/GeckoProfiler.cpp
@@ -162,17 +162,17 @@ GeckoProfilerRuntime::profileString(JSSc
{
auto locked = strings.lock();
MOZ_ASSERT(locked->initialized());
ProfileStringMap::AddPtr s = locked->lookupForAdd(script);
if (!s) {
auto str = allocProfileString(script, maybeFun);
- if (!str || !locked->add(s, script, mozilla::Move(str)))
+ if (!str || !locked->add(s, script, std::move(str)))
return nullptr;
}
return s->value().get();
}
void
GeckoProfilerRuntime::onScriptFinalized(JSScript* script)
--- a/js/src/vm/HelperThreads.cpp
+++ b/js/src/vm/HelperThreads.cpp
@@ -1467,17 +1467,17 @@ GlobalHelperThreadState::scheduleCompres
{
auto& pending = compressionPendingList(lock);
auto& worklist = compressionWorklist(lock);
for (size_t i = 0; i < pending.length(); i++) {
if (pending[i]->shouldStart()) {
// OOMing during appending results in the task not being scheduled
// and deleted.
- Unused << worklist.append(Move(pending[i]));
+ Unused << worklist.append(std::move(pending[i]));
remove(pending, &i);
}
}
}
bool
GlobalHelperThreadState::canStartGCHelperTask(const AutoLockHelperThreadState& lock)
{
@@ -2095,49 +2095,49 @@ void
HelperThread::handleCompressionWorkload(AutoLockHelperThreadState& locked)
{
MOZ_ASSERT(HelperThreadState().canStartCompressionTask(locked));
MOZ_ASSERT(idle());
UniquePtr<SourceCompressionTask> task;
{
auto& worklist = HelperThreadState().compressionWorklist(locked);
- task = Move(worklist.back());
+ task = std::move(worklist.back());
worklist.popBack();
currentTask.emplace(task.get());
}
{
AutoUnlockHelperThreadState unlock(locked);
TraceLoggerThread* logger = TraceLoggerForCurrentThread();
AutoTraceLog logCompile(logger, TraceLogger_CompressSource);
task->work();
}
{
AutoEnterOOMUnsafeRegion oomUnsafe;
- if (!HelperThreadState().compressionFinishedList(locked).append(Move(task)))
+ if (!HelperThreadState().compressionFinishedList(locked).append(std::move(task)))
oomUnsafe.crash("handleCompressionWorkload");
}
currentTask.reset();
// Notify the main thread in case it is waiting for the compression to finish.
HelperThreadState().notifyAll(GlobalHelperThreadState::CONSUMER, locked);
}
bool
js::EnqueueOffThreadCompression(JSContext* cx, UniquePtr<SourceCompressionTask> task)
{
AutoLockHelperThreadState lock;
auto& pending = HelperThreadState().compressionPendingList(lock);
- if (!pending.append(Move(task))) {
+ if (!pending.append(std::move(task))) {
if (!cx->helperThread())
ReportOutOfMemory(cx);
return false;
}
return true;
}
--- a/js/src/vm/HelperThreads.h
+++ b/js/src/vm/HelperThreads.h
@@ -190,17 +190,17 @@ class GlobalHelperThreadState
void notifyOne(CondVar which, const AutoLockHelperThreadState&);
// Helper method for removing items from the vectors below while iterating over them.
template <typename T>
void remove(T& vector, size_t* index)
{
// Self-moving is undefined behavior.
if (*index != vector.length() - 1)
- vector[*index] = mozilla::Move(vector.back());
+ vector[*index] = std::move(vector.back());
(*index)--;
vector.popBack();
}
IonBuilderVector& ionWorklist(const AutoLockHelperThreadState&) {
return ionWorklist_;
}
IonBuilderVector& ionFinishedList(const AutoLockHelperThreadState&) {
--- a/js/src/vm/JSCompartment.cpp
+++ b/js/src/vm/JSCompartment.cpp
@@ -111,17 +111,17 @@ ObjectRealm::init(JSContext* maybecx)
ReportOutOfMemory(maybecx);
return false;
}
NativeIteratorSentinel sentinel(NativeIterator::allocateSentinel(maybecx));
if (!sentinel)
return false;
- iteratorSentinel_ = Move(sentinel);
+ iteratorSentinel_ = std::move(sentinel);
enumerators = iteratorSentinel_.get();
return true;
}
bool
Realm::init(JSContext* maybecx)
{
// Initialize JSCompartment. This is temporary until Realm and
@@ -200,17 +200,17 @@ Realm::ensureJitRealmExists(JSContext* c
UniquePtr<JitRealm> jitRealm = cx->make_unique<JitRealm>();
if (!jitRealm)
return false;
if (!jitRealm->initialize(cx))
return false;
- jitRealm_ = Move(jitRealm);
+ jitRealm_ = std::move(jitRealm);
return true;
}
#ifdef JSGC_HASH_TABLE_CHECKS
void
js::DtoaCache::checkCacheAfterMovingGC()
{
@@ -553,17 +553,17 @@ ObjectRealm::getOrCreateNonSyntacticLexi
{
MOZ_ASSERT(&ObjectRealm::get(enclosing) == this);
if (!nonSyntacticLexicalEnvironments_) {
auto map = cx->make_unique<ObjectWeakMap>(cx);
if (!map || !map->init())
return nullptr;
- nonSyntacticLexicalEnvironments_ = Move(map);
+ nonSyntacticLexicalEnvironments_ = std::move(map);
}
// If a wrapped WithEnvironmentObject was passed in, unwrap it, as we may
// be creating different WithEnvironmentObject wrappers each time.
RootedObject key(cx, enclosing);
if (enclosing->is<WithEnvironmentObject>()) {
MOZ_ASSERT(!enclosing->as<WithEnvironmentObject>().isSyntactic());
key = &enclosing->as<WithEnvironmentObject>().object();
@@ -1095,17 +1095,17 @@ Realm::setNewObjectMetadata(JSContext* c
MOZ_ASSERT(metadata->realm() == obj->realm());
assertSameCompartment(cx, metadata);
if (!objects_.objectMetadataTable) {
auto table = cx->make_unique<ObjectWeakMap>(cx);
if (!table || !table->init())
oomUnsafe.crash("setNewObjectMetadata");
- objects_.objectMetadataTable = Move(table);
+ objects_.objectMetadataTable = std::move(table);
}
if (!objects_.objectMetadataTable->add(cx, obj, metadata))
oomUnsafe.crash("setNewObjectMetadata");
}
}
static bool
--- a/js/src/vm/JSCompartment.h
+++ b/js/src/vm/JSCompartment.h
@@ -382,17 +382,17 @@ class WrapperMap
}
MOZ_MUST_USE bool put(const CrossCompartmentKey& k, const JS::Value& v) {
JSCompartment* c = const_cast<CrossCompartmentKey&>(k).compartment();
MOZ_ASSERT(k.is<JSString*>() == !c);
auto p = map.lookupForAdd(c);
if (!p) {
InnerMap m;
- if (!m.init(InitialInnerMapSize) || !map.add(p, c, mozilla::Move(m)))
+ if (!m.init(InitialInnerMapSize) || !map.add(p, c, std::move(m)))
return false;
}
return p->value().put(k, v);
}
size_t sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) {
size_t size = map.sizeOfExcludingThis(mallocSizeOf);
for (OuterMap::Enum e(map); !e.empty(); e.popFront())
--- a/js/src/vm/JSFunction.cpp
+++ b/js/src/vm/JSFunction.cpp
@@ -848,17 +848,17 @@ CreateFunctionPrototype(JSContext* cx, J
UniqueTwoByteChars source(InflateString(cx, rawSource, sourceLen));
if (!source)
return nullptr;
ScriptSource* ss = cx->new_<ScriptSource>();
if (!ss)
return nullptr;
ScriptSourceHolder ssHolder(ss);
- if (!ss->setSource(cx, mozilla::Move(source), sourceLen))
+ if (!ss->setSource(cx, std::move(source), sourceLen))
return nullptr;
CompileOptions options(cx);
options.setIntroductionType("Function.prototype")
.setNoScriptRval(true);
if (!ss->initFromOptions(cx, options))
return nullptr;
RootedScriptSourceObject sourceObject(cx, ScriptSourceObject::create(cx, ss));
--- a/js/src/vm/JSONParser.h
+++ b/js/src/vm/JSONParser.h
@@ -119,21 +119,21 @@ class MOZ_STACK_CLASS JSONParserBase
{}
~JSONParserBase();
// Allow move construction for use with Rooted.
JSONParserBase(JSONParserBase&& other)
: v(other.v),
cx(other.cx),
errorHandling(other.errorHandling),
- stack(mozilla::Move(other.stack)),
- freeElements(mozilla::Move(other.freeElements)),
- freeProperties(mozilla::Move(other.freeProperties))
+ stack(std::move(other.stack)),
+ freeElements(std::move(other.freeElements)),
+ freeProperties(std::move(other.freeProperties))
#ifdef DEBUG
- , lastToken(mozilla::Move(other.lastToken))
+ , lastToken(std::move(other.lastToken))
#endif
{}
Value numberValue() const {
MOZ_ASSERT(lastToken == Number);
MOZ_ASSERT(v.isNumber());
return v;
@@ -209,17 +209,17 @@ class MOZ_STACK_CLASS JSONParser : publi
begin(current),
end(data.end())
{
MOZ_ASSERT(current <= end);
}
/* Allow move construction for use with Rooted. */
JSONParser(JSONParser&& other)
- : JSONParserBase(mozilla::Move(other)),
+ : JSONParserBase(std::move(other)),
current(other.current),
begin(other.begin),
end(other.end)
{}
/*
* Parse the JSON data specified at construction time. If it parses
* successfully, store the prescribed value in *vp and return true. If an
--- a/js/src/vm/JSScript-inl.h
+++ b/js/src/vm/JSScript-inl.h
@@ -23,36 +23,36 @@ namespace js {
ScriptCounts::ScriptCounts()
: pcCounts_(),
throwCounts_(),
ionCounts_(nullptr)
{
}
ScriptCounts::ScriptCounts(PCCountsVector&& jumpTargets)
- : pcCounts_(Move(jumpTargets)),
+ : pcCounts_(std::move(jumpTargets)),
throwCounts_(),
ionCounts_(nullptr)
{
}
ScriptCounts::ScriptCounts(ScriptCounts&& src)
- : pcCounts_(Move(src.pcCounts_)),
- throwCounts_(Move(src.throwCounts_)),
- ionCounts_(Move(src.ionCounts_))
+ : pcCounts_(std::move(src.pcCounts_)),
+ throwCounts_(std::move(src.throwCounts_)),
+ ionCounts_(std::move(src.ionCounts_))
{
src.ionCounts_ = nullptr;
}
ScriptCounts&
ScriptCounts::operator=(ScriptCounts&& src)
{
- pcCounts_ = Move(src.pcCounts_);
- throwCounts_ = Move(src.throwCounts_);
- ionCounts_ = Move(src.ionCounts_);
+ pcCounts_ = std::move(src.pcCounts_);
+ throwCounts_ = std::move(src.throwCounts_);
+ ionCounts_ = std::move(src.ionCounts_);
src.ionCounts_ = nullptr;
return *this;
}
ScriptCounts::~ScriptCounts()
{
js_delete(ionCounts_);
}
@@ -60,18 +60,18 @@ ScriptCounts::~ScriptCounts()
ScriptAndCounts::ScriptAndCounts(JSScript* script)
: script(script),
scriptCounts()
{
script->releaseScriptCounts(&scriptCounts);
}
ScriptAndCounts::ScriptAndCounts(ScriptAndCounts&& sac)
- : script(Move(sac.script)),
- scriptCounts(Move(sac.scriptCounts))
+ : script(std::move(sac.script)),
+ scriptCounts(std::move(sac.scriptCounts))
{
}
void
SetFrameArgumentsObject(JSContext* cx, AbstractFramePtr frame,
HandleScript script, JSObject* argsobj);
/* static */ inline JSFunction*
--- a/js/src/vm/JSScript.cpp
+++ b/js/src/vm/JSScript.cpp
@@ -1054,28 +1054,28 @@ JSScript::initScriptCounts(JSContext* cx
// Create realm's scriptCountsMap if necessary.
if (!realm()->scriptCountsMap) {
auto map = cx->make_unique<ScriptCountsMap>();
if (!map || !map->init()) {
ReportOutOfMemory(cx);
return false;
}
- realm()->scriptCountsMap = Move(map);
+ realm()->scriptCountsMap = std::move(map);
}
// Allocate the ScriptCounts.
- UniqueScriptCounts sc = cx->make_unique<ScriptCounts>(Move(base));
+ UniqueScriptCounts sc = cx->make_unique<ScriptCounts>(std::move(base));
if (!sc) {
ReportOutOfMemory(cx);
return false;
}
// Register the current ScriptCounts in the realm's map.
- if (!realm()->scriptCountsMap->putNew(this, Move(sc))) {
+ if (!realm()->scriptCountsMap->putNew(this, std::move(sc))) {
ReportOutOfMemory(cx);
return false;
}
// safe to set this; we can't fail after this point.
bitFields_.hasScriptCounts_ = true;
// Enable interrupts in any interpreter frames running on this script. This
@@ -1284,17 +1284,17 @@ JSScript::clearHasScriptCounts()
{
bitFields_.hasScriptCounts_ = false;
}
void
JSScript::releaseScriptCounts(ScriptCounts* counts)
{
ScriptCountsMap::Ptr p = GetScriptCountsMapEntry(this);
- *counts = Move(*p->value().get());
+ *counts = std::move(*p->value().get());
realm()->scriptCountsMap->remove(p);
bitFields_.hasScriptCounts_ = false;
}
void
JSScript::destroyScriptCounts()
{
if (hasScriptCounts()) {
@@ -1468,28 +1468,28 @@ UncompressedSourceCache::AutoHoldEntry::
cache_ = cache;
sourceChunk_ = sourceChunk;
}
void
UncompressedSourceCache::AutoHoldEntry::holdChars(UniqueTwoByteChars chars)
{
MOZ_ASSERT(!cache_ && !sourceChunk_.valid() && !charsToFree_);
- charsToFree_ = Move(chars);
+ charsToFree_ = std::move(chars);
}
void
UncompressedSourceCache::AutoHoldEntry::deferDelete(UniqueTwoByteChars chars)
{
// Take ownership of source chars now the cache is being purged. Remove our
// reference to the ScriptSource which might soon be destroyed.
MOZ_ASSERT(cache_ && sourceChunk_.valid() && !charsToFree_);
cache_ = nullptr;
sourceChunk_ = ScriptSourceChunk();
- charsToFree_ = Move(chars);
+ charsToFree_ = std::move(chars);
}
UncompressedSourceCache::AutoHoldEntry::~AutoHoldEntry()
{
if (cache_) {
MOZ_ASSERT(sourceChunk_.valid());
cache_->releaseEntry(*this);
}
@@ -1529,35 +1529,35 @@ UncompressedSourceCache::put(const Scrip
{
MOZ_ASSERT(!holder_);
if (!map_) {
UniquePtr<Map> map = MakeUnique<Map>();
if (!map || !map->init())
return false;
- map_ = Move(map);
+ map_ = std::move(map);
}
- if (!map_->put(ssc, Move(str)))
+ if (!map_->put(ssc, std::move(str)))
return false;
holdEntry(holder, ssc);
return true;
}
void
UncompressedSourceCache::purge()
{
if (!map_)
return;
for (Map::Range r = map_->all(); !r.empty(); r.popFront()) {
if (holder_ && r.front().key() == holder_->sourceChunk()) {
- holder_->deferDelete(Move(r.front().value()));
+ holder_->deferDelete(std::move(r.front().value()));
holder_ = nullptr;
}
}
map_.reset();
}
size_t
@@ -1600,17 +1600,17 @@ ScriptSource::chunkChars(JSContext* cx,
{
JS_ReportOutOfMemory(cx);
return nullptr;
}
decompressed[lengthWithNull - 1] = '\0';
const char16_t* ret = decompressed.get();
- if (!cx->caches().uncompressedSourceCache.put(ssc, Move(decompressed), holder)) {
+ if (!cx->caches().uncompressedSourceCache.put(ssc, std::move(decompressed), holder)) {
JS_ReportOutOfMemory(cx);
return nullptr;
}
return ret;
}
ScriptSource::PinnedChars::PinnedChars(JSContext* cx, ScriptSource* source,
UncompressedSourceCache::AutoHoldEntry& holder,
@@ -1641,17 +1641,17 @@ ScriptSource::movePendingCompressedSourc
if (!pendingCompressed_)
return;
MOZ_ASSERT(data.is<Missing>() || data.is<Uncompressed>());
MOZ_ASSERT_IF(data.is<Uncompressed>(),
data.as<Uncompressed>().string.length() ==
pendingCompressed_->uncompressedLength);
- data = SourceType(Compressed(mozilla::Move(pendingCompressed_->raw),
+ data = SourceType(Compressed(std::move(pendingCompressed_->raw),
pendingCompressed_->uncompressedLength));
pendingCompressed_ = mozilla::Nothing();
}
const char16_t*
ScriptSource::chars(JSContext* cx, UncompressedSourceCache::AutoHoldEntry& holder,
size_t begin, size_t len)
{
@@ -1723,17 +1723,17 @@ ScriptSource::chars(JSContext* cx, Uncom
cursor += numChars;
}
*cursor++ = '\0';
MOZ_ASSERT(size_t(cursor - decompressed.get()) == lengthWithNull);
// Transfer ownership to |holder|.
const char16_t* ret = decompressed.get();
- holder.holdChars(Move(decompressed));
+ holder.holdChars(std::move(decompressed));
return ret;
}
JSFlatString*
ScriptSource::substring(JSContext* cx, size_t start, size_t stop)
{
MOZ_ASSERT(start <= stop);
size_t len = stop - start;
@@ -1779,30 +1779,30 @@ ScriptSource::functionBodyString(JSConte
size_t stop = length() - (sizeof(FunctionConstructorFinalBrace) - 1);
return substring(cx, start, stop);
}
MOZ_MUST_USE bool
ScriptSource::setSource(JSContext* cx, UniqueTwoByteChars&& source, size_t length)
{
auto& cache = cx->zone()->runtimeFromAnyThread()->sharedImmutableStrings();
- auto deduped = cache.getOrCreate(mozilla::Move(source), length);
+ auto deduped = cache.getOrCreate(std::move(source), length);
if (!deduped) {
ReportOutOfMemory(cx);
return false;
}
- setSource(mozilla::Move(*deduped));
+ setSource(std::move(*deduped));
return true;
}
void
ScriptSource::setSource(SharedImmutableTwoByteString&& string)
{
MOZ_ASSERT(data.is<Missing>());
- data = SourceType(Uncompressed(mozilla::Move(string)));
+ data = SourceType(Uncompressed(std::move(string)));
}
bool
ScriptSource::tryCompressOffThread(JSContext* cx)
{
if (!data.is<Uncompressed>())
return true;
@@ -1836,44 +1836,44 @@ ScriptSource::tryCompressOffThread(JSCon
// Heap allocate the task. It will be freed upon compression
// completing in AttachFinishedCompressedSources.
auto task = MakeUnique<SourceCompressionTask>(cx->runtime(), this);
if (!task) {
ReportOutOfMemory(cx);
return false;
}
- return EnqueueOffThreadCompression(cx, Move(task));
+ return EnqueueOffThreadCompression(cx, std::move(task));
}
MOZ_MUST_USE bool
ScriptSource::setCompressedSource(JSContext* cx, UniqueChars&& raw, size_t rawLength,
size_t sourceLength)
{
MOZ_ASSERT(raw);
auto& cache = cx->zone()->runtimeFromAnyThread()->sharedImmutableStrings();
- auto deduped = cache.getOrCreate(mozilla::Move(raw), rawLength);
+ auto deduped = cache.getOrCreate(std::move(raw), rawLength);
if (!deduped) {
ReportOutOfMemory(cx);
return false;
}
- setCompressedSource(mozilla::Move(*deduped), sourceLength);
+ setCompressedSource(std::move(*deduped), sourceLength);
return true;
}
void
ScriptSource::setCompressedSource(SharedImmutableString&& raw, size_t uncompressedLength)
{
MOZ_ASSERT(data.is<Missing>() || data.is<Uncompressed>());
MOZ_ASSERT_IF(data.is<Uncompressed>(),
data.as<Uncompressed>().string.length() == uncompressedLength);
if (pinnedCharsStack_)
- pendingCompressed_ = mozilla::Some(Compressed(mozilla::Move(raw), uncompressedLength));
+ pendingCompressed_ = mozilla::Some(Compressed(std::move(raw), uncompressedLength));
else
- data = SourceType(Compressed(mozilla::Move(raw), uncompressedLength));
+ data = SourceType(Compressed(std::move(raw), uncompressedLength));
}
bool
ScriptSource::setSourceCopy(JSContext* cx, SourceBufferHolder& srcBuf)
{
MOZ_ASSERT(!hasSourceData());
JSRuntime* runtime = cx->zone()->runtimeFromAnyThread();
@@ -1882,17 +1882,17 @@ ScriptSource::setSourceCopy(JSContext* c
return srcBuf.ownsChars()
? UniqueTwoByteChars(srcBuf.take())
: DuplicateString(srcBuf.get(), srcBuf.length());
});
if (!deduped) {
ReportOutOfMemory(cx);
return false;
}
- setSource(mozilla::Move(*deduped));
+ setSource(std::move(*deduped));
return true;
}
static MOZ_MUST_USE bool
reallocUniquePtr(UniqueChars& unique, size_t size)
{
auto newPtr = static_cast<char*>(js_realloc(unique.get(), size));
@@ -1968,25 +1968,25 @@ SourceCompressionTask::work()
return;
comp.finish(compressed.get(), totalBytes);
if (shouldCancel())
return;
auto& strings = runtime_->sharedImmutableStrings();
- resultString_ = strings.getOrCreate(mozilla::Move(compressed), totalBytes);
+ resultString_ = strings.getOrCreate(std::move(compressed), totalBytes);
}
void
SourceCompressionTask::complete()
{
if (!shouldCancel() && resultString_) {
ScriptSource* source = sourceHolder_.get();
- source->setCompressedSource(mozilla::Move(*resultString_), source->length());
+ source->setCompressedSource(std::move(*resultString_), source->length());
}
}
void
ScriptSource::addSizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf,
JS::ScriptSourceInfo* info) const
{
info->misc += mallocSizeOf(this) +
@@ -2130,21 +2130,21 @@ ScriptSource::performXDR(XDRState<mode>*
size_t byteLen = compressedLength ? compressedLength : (len * sizeof(char16_t));
if (mode == XDR_DECODE) {
UniqueChars bytes(xdr->cx()->template pod_malloc<char>(Max<size_t>(byteLen, 1)));
if (!bytes)
return xdr->fail(JS::TranscodeResult_Throw);
MOZ_TRY(xdr->codeBytes(bytes.get(), byteLen));
if (compressedLength) {
- if (!setCompressedSource(xdr->cx(), mozilla::Move(bytes), byteLen, len))
+ if (!setCompressedSource(xdr->cx(), std::move(bytes), byteLen, len))
return xdr->fail(JS::TranscodeResult_Throw);
} else {
UniqueTwoByteChars source(reinterpret_cast<char16_t*>(bytes.release()));
- if (!setSource(xdr->cx(), mozilla::Move(source), len))
+ if (!setSource(xdr->cx(), std::move(source), len))
return xdr->fail(JS::TranscodeResult_Throw);
}
} else {
RawDataMatcher rdm;
void* p = data.match(rdm);
MOZ_TRY(xdr->codeBytes(p, byteLen));
}
}
@@ -2693,27 +2693,27 @@ JSScript::initScriptName(JSContext* cx)
// Create realm's scriptNameMap if necessary.
if (!realm()->scriptNameMap) {
auto map = cx->make_unique<ScriptNameMap>();
if (!map || !map->init()) {
ReportOutOfMemory(cx);
return false;
}
- realm()->scriptNameMap = Move(map);
+ realm()->scriptNameMap = std::move(map);
}
UniqueChars name(js_strdup(filename()));
if (!name) {
ReportOutOfMemory(cx);
return false;
}
// Register the script name in the realm's map.
- if (!realm()->scriptNameMap->putNew(this, Move(name))) {
+ if (!realm()->scriptNameMap->putNew(this, std::move(name))) {
ReportOutOfMemory(cx);
return false;
}
return true;
}
static inline uint8_t*
@@ -3752,20 +3752,20 @@ JSScript::ensureHasDebugScript(JSContext
return false;
/* Create realm's debugScriptMap if necessary. */
if (!realm()->debugScriptMap) {
auto map = cx->make_unique<DebugScriptMap>();
if (!map || !map->init())
return false;
- realm()->debugScriptMap = Move(map);
+ realm()->debugScriptMap = std::move(map);
}
- if (!realm()->debugScriptMap->putNew(this, Move(debug)))
+ if (!realm()->debugScriptMap->putNew(this, std::move(debug)))
return false;
bitFields_.hasDebugScript_ = true; // safe to set this; we can't fail after this point
/*
* Ensure that any Interpret() instances running on this script have
* interrupts enabled. The interrupts must stay enabled until the
* debug state is destroyed.
--- a/js/src/vm/JSScript.h
+++ b/js/src/vm/JSScript.h
@@ -403,27 +403,27 @@ class ScriptSource
struct Missing { };
struct Uncompressed
{
SharedImmutableTwoByteString string;
explicit Uncompressed(SharedImmutableTwoByteString&& str)
- : string(mozilla::Move(str))
+ : string(std::move(str))
{ }
};
struct Compressed
{
SharedImmutableString raw;
size_t uncompressedLength;
Compressed(SharedImmutableString&& raw, size_t uncompressedLength)
- : raw(mozilla::Move(raw))
+ : raw(std::move(raw))
, uncompressedLength(uncompressedLength)
{ }
};
using SourceType = mozilla::Variant<Missing, Uncompressed, Compressed>;
SourceType data;
// If the GC attempts to call setCompressedSource with PinnedChars
--- a/js/src/vm/MemoryMetrics.cpp
+++ b/js/src/vm/MemoryMetrics.cpp
@@ -177,28 +177,28 @@ NotableStringInfo::NotableStringInfo(JSS
if (str->hasLatin1Chars())
StoreStringChars<Latin1Char>(buffer, bufferSize, str);
else
StoreStringChars<char16_t>(buffer, bufferSize, str);
}
NotableStringInfo::NotableStringInfo(NotableStringInfo&& info)
- : StringInfo(Move(info)),
+ : StringInfo(std::move(info)),
length(info.length)
{
buffer = info.buffer;
info.buffer = nullptr;
}
NotableStringInfo& NotableStringInfo::operator=(NotableStringInfo&& info)
{
MOZ_ASSERT(this != &info, "self-move assignment is prohibited");
this->~NotableStringInfo();
- new (this) NotableStringInfo(Move(info));
+ new (this) NotableStringInfo(std::move(info));
return *this;
}
NotableClassInfo::NotableClassInfo()
: ClassInfo(),
className_(nullptr)
{
}
@@ -209,27 +209,27 @@ NotableClassInfo::NotableClassInfo(const
size_t bytes = strlen(className) + 1;
className_ = js_pod_malloc<char>(bytes);
if (!className_)
MOZ_CRASH("oom");
PodCopy(className_, className, bytes);
}
NotableClassInfo::NotableClassInfo(NotableClassInfo&& info)
- : ClassInfo(Move(info))
+ : ClassInfo(std::move(info))
{
className_ = info.className_;
info.className_ = nullptr;
}
NotableClassInfo& NotableClassInfo::operator=(NotableClassInfo&& info)
{
MOZ_ASSERT(this != &info, "self-move assignment is prohibited");
this->~NotableClassInfo();
- new (this) NotableClassInfo(Move(info));
+ new (this) NotableClassInfo(std::move(info));
return *this;
}
NotableScriptSourceInfo::NotableScriptSourceInfo()
: ScriptSourceInfo(),
filename_(nullptr)
{
}
@@ -240,27 +240,27 @@ NotableScriptSourceInfo::NotableScriptSo
size_t bytes = strlen(filename) + 1;
filename_ = js_pod_malloc<char>(bytes);
if (!filename_)
MOZ_CRASH("oom");
PodCopy(filename_, filename, bytes);
}
NotableScriptSourceInfo::NotableScriptSourceInfo(NotableScriptSourceInfo&& info)
- : ScriptSourceInfo(Move(info))
+ : ScriptSourceInfo(std::move(info))
{
filename_ = info.filename_;
info.filename_ = nullptr;
}
NotableScriptSourceInfo& NotableScriptSourceInfo::operator=(NotableScriptSourceInfo&& info)
{
MOZ_ASSERT(this != &info, "self-move assignment is prohibited");
this->~NotableScriptSourceInfo();
- new (this) NotableScriptSourceInfo(Move(info));
+ new (this) NotableScriptSourceInfo(std::move(info));
return *this;
}
} // namespace JS
typedef HashSet<ScriptSource*, DefaultHasher<ScriptSource*>, SystemAllocPolicy> SourceSet;
--- a/js/src/vm/ObjectGroup.cpp
+++ b/js/src/vm/ObjectGroup.cpp
@@ -1360,27 +1360,27 @@ struct ObjectGroupRealm::AllocationSiteK
AllocationSiteKey(const AllocationSiteKey& key)
: script(key.script),
offset(key.offset),
kind(key.kind),
proto(key.proto)
{ }
AllocationSiteKey(AllocationSiteKey&& key)
- : script(mozilla::Move(key.script)),
+ : script(std::move(key.script)),
offset(key.offset),
kind(key.kind),
- proto(mozilla::Move(key.proto))
+ proto(std::move(key.proto))
{ }
void operator=(AllocationSiteKey&& key) {
- script = mozilla::Move(key.script);
+ script = std::move(key.script);
offset = key.offset;
kind = key.kind;
- proto = mozilla::Move(key.proto);
+ proto = std::move(key.proto);
}
static inline uint32_t hash(AllocationSiteKey key) {
return uint32_t(size_t(key.script.unbarrieredGet()->offsetToPC(key.offset)) ^ key.kind ^
MovableCellHasher<JSObject*>::hash(key.proto.unbarrieredGet()));
}
static inline bool match(const AllocationSiteKey& a, const AllocationSiteKey& b) {
--- a/js/src/vm/RegExpObject.cpp
+++ b/js/src/vm/RegExpObject.cpp
@@ -1035,17 +1035,17 @@ RegExpShared::compile(JSContext* cx, Mut
RegExpCompilation& compilation = re->compilation(mode, input->hasLatin1Chars());
if (code.jitCode) {
// First copy the tables. GC can purge the tables if the RegExpShared
// has no JIT code, so it's important to do this right before setting
// compilation.jitCode (to ensure no purging happens between adding the
// tables and setting the JIT code).
for (size_t i = 0; i < tables.length(); i++) {
- if (!re->addTable(Move(tables[i])))
+ if (!re->addTable(std::move(tables[i])))
return false;
}
compilation.jitCode = code.jitCode;
} else if (code.byteCode) {
MOZ_ASSERT(tables.empty(), "RegExpInterpreter does not use data tables");
compilation.byteCode = code.byteCode;
}
--- a/js/src/vm/RegExpShared.h
+++ b/js/src/vm/RegExpShared.h
@@ -158,17 +158,17 @@ class RegExpShared : public gc::TenuredC
// Execute this RegExp on input starting from searchIndex, filling in
// matches if specified and otherwise only determining if there is a match.
static RegExpRunStatus execute(JSContext* cx, MutableHandleRegExpShared res,
HandleLinearString input, size_t searchIndex,
VectorMatchPairs* matches, size_t* endIndex);
// Register a table with this RegExpShared, and take ownership.
bool addTable(JitCodeTable table) {
- return tables.append(Move(table));
+ return tables.append(std::move(table));
}
/* Accessors */
size_t getParenCount() const {
MOZ_ASSERT(isCompiled());
return parenCount;
}
--- a/js/src/vm/SavedStacks.cpp
+++ b/js/src/vm/SavedStacks.cpp
@@ -1287,17 +1287,17 @@ SavedStacks::saveCurrentStack(JSContext*
!cx->global() ||
!cx->global()->isStandardClassResolved(JSProto_Object))
{
frame.set(nullptr);
return true;
}
AutoGeckoProfilerEntry labelFrame(cx, "js::SavedStacks::saveCurrentStack");
- return insertFrames(cx, frame, mozilla::Move(capture));
+ return insertFrames(cx, frame, std::move(capture));
}
bool
SavedStacks::copyAsyncStack(JSContext* cx, HandleObject asyncStack, HandleString asyncCause,
MutableHandleSavedFrame adoptedStack,
const Maybe<size_t>& maxFrameCount)
{
MOZ_ASSERT(initialized());
--- a/js/src/vm/Scope.cpp
+++ b/js/src/vm/Scope.cpp
@@ -312,17 +312,17 @@ Scope::create(JSContext* cx, ScopeKind k
{
Scope* scope = create(cx, kind, enclosing, envShape);
if (!scope)
return nullptr;
// It is an invariant that all Scopes that have data (currently, all
// ScopeKinds except With) must have non-null data.
MOZ_ASSERT(data);
- scope->initData(Move(data));
+ scope->initData(std::move(data));
return scope;
}
uint32_t
Scope::chainLength() const
{
uint32_t length = 0;
@@ -380,41 +380,41 @@ Scope::clone(JSContext* cx, HandleScope
}
case ScopeKind::FunctionBodyVar:
case ScopeKind::ParameterExpressionVar: {
Rooted<VarScope::Data*> original(cx, &scope->as<VarScope>().data());
UniquePtr<VarScope::Data> dataClone = CopyScopeData<VarScope>(cx, original);
if (!dataClone)
return nullptr;
- return create(cx, scope->kind_, enclosing, envShape, Move(dataClone));
+ return create(cx, scope->kind_, enclosing, envShape, std::move(dataClone));
}
case ScopeKind::Lexical:
case ScopeKind::SimpleCatch:
case ScopeKind::Catch:
case ScopeKind::NamedLambda:
case ScopeKind::StrictNamedLambda: {
Rooted<LexicalScope::Data*> original(cx, &scope->as<LexicalScope>().data());
UniquePtr<LexicalScope::Data> dataClone = CopyScopeData<LexicalScope>(cx, original);
if (!dataClone)
return nullptr;
- return create(cx, scope->kind_, enclosing, envShape, Move(dataClone));
+ return create(cx, scope->kind_, enclosing, envShape, std::move(dataClone));
}
case ScopeKind::With:
return create(cx, scope->kind_, enclosing, envShape);
case ScopeKind::Eval:
case ScopeKind::StrictEval: {
Rooted<EvalScope::Data*> original(cx, &scope->as<EvalScope>().data());
UniquePtr<EvalScope::Data> dataClone = CopyScopeData<EvalScope>(cx, original);
if (!dataClone)
return nullptr;
- return create(cx, scope->kind_, enclosing, envShape, Move(dataClone));
+ return create(cx, scope->kind_, enclosing, envShape, std::move(dataClone));
}
case ScopeKind::Global:
case ScopeKind::NonSyntactic:
MOZ_CRASH("Use GlobalScope::clone.");
break;
case ScopeKind::WasmFunction:
@@ -549,17 +549,17 @@ LexicalScope::createWithData(JSContext*
RootedShape envShape(cx);
BindingIter bi(*data, firstFrameSlot, isNamedLambda);
if (!PrepareScopeData<LexicalScope>(cx, bi, data, &LexicalEnvironmentObject::class_,
BaseShape::NOT_EXTENSIBLE | BaseShape::DELEGATE, &envShape))
{
return nullptr;
}
- Scope* scope = Scope::create(cx, kind, enclosing, envShape, Move(data.get()));
+ Scope* scope = Scope::create(cx, kind, enclosing, envShape, std::move(data.get()));
if (!scope)
return nullptr;
MOZ_ASSERT(scope->as<LexicalScope>().firstFrameSlot() == firstFrameSlot);
return &scope->as<LexicalScope>();
}
/* static */ Shape*
LexicalScope::getEmptyExtensibleEnvironmentShape(JSContext* cx)
@@ -684,17 +684,17 @@ FunctionScope::createWithData(JSContext*
return nullptr;
}
Scope* scope = Scope::create(cx, ScopeKind::Function, enclosing, envShape);
if (!scope)
return nullptr;
funScope = &scope->as<FunctionScope>();
- funScope->initData(Move(data.get()));
+ funScope->initData(std::move(data.get()));
}
return funScope;
}
JSScript*
FunctionScope::script() const
{
@@ -742,17 +742,17 @@ FunctionScope::clone(JSContext* cx, Hand
dataClone->canonicalFunction.init(fun);
Scope* scopeClone = Scope::create(cx, scope->kind(), enclosing, envShape);
if (!scopeClone)
return nullptr;
funScopeClone = &scopeClone->as<FunctionScope>();
- funScopeClone->initData(Move(dataClone.get()));
+ funScopeClone->initData(std::move(dataClone.get()));
}
return funScopeClone;
}
template <XDRMode mode>
/* static */ XDRResult
FunctionScope::XDR(XDRState<mode>* xdr, HandleFunction fun, HandleScope enclosing,
@@ -857,17 +857,17 @@ VarScope::createWithData(JSContext* cx,
// - Extensible scopes (i.e., due to direct eval)
// - Being a generator
if (!envShape && needsEnvironment) {
envShape = getEmptyEnvironmentShape(cx);
if (!envShape)
return nullptr;
}
- Scope* scope = Scope::create(cx, kind, enclosing, envShape, Move(data.get()));
+ Scope* scope = Scope::create(cx, kind, enclosing, envShape, std::move(data.get()));
if (!scope)
return nullptr;
return &scope->as<VarScope>();
}
/* static */ Shape*
VarScope::getEmptyEnvironmentShape(JSContext* cx)
{
@@ -954,31 +954,31 @@ GlobalScope::create(JSContext* cx, Scope
GlobalScope::createWithData(JSContext* cx, ScopeKind kind, MutableHandle<UniquePtr<Data>> data)
{
MOZ_ASSERT(data);
// The global scope has no environment shape. Its environment is the
// global lexical scope and the global object or non-syntactic objects
// created by embedding, all of which are not only extensible but may
// have names on them deleted.
- Scope* scope = Scope::create(cx, kind, nullptr, nullptr, Move(data.get()));
+ Scope* scope = Scope::create(cx, kind, nullptr, nullptr, std::move(data.get()));
if (!scope)
return nullptr;
return &scope->as<GlobalScope>();
}
/* static */ GlobalScope*
GlobalScope::clone(JSContext* cx, Handle<GlobalScope*> scope, ScopeKind kind)
{
Rooted<Data*> dataOriginal(cx, &scope->as<GlobalScope>().data());
Rooted<UniquePtr<Data>> dataClone(cx, CopyScopeData<GlobalScope>(cx, dataOriginal));
if (!dataClone)
return nullptr;
- Scope* scopeClone = Scope::create(cx, kind, nullptr, nullptr, Move(dataClone.get()));
+ Scope* scopeClone = Scope::create(cx, kind, nullptr, nullptr, std::move(dataClone.get()));
if (!scopeClone)
return nullptr;
return &scopeClone->as<GlobalScope>();
}
template <XDRMode mode>
/* static */ XDRResult
GlobalScope::XDR(XDRState<mode>* xdr, ScopeKind kind, MutableHandleScope scope)
@@ -1065,17 +1065,17 @@ EvalScope::createWithData(JSContext* cx,
// Strict eval and direct eval in parameter expressions always get their own
// var environment even if there are no bindings.
if (!envShape && scopeKind == ScopeKind::StrictEval) {
envShape = getEmptyEnvironmentShape(cx);
if (!envShape)
return nullptr;
}
- Scope* scope = Scope::create(cx, scopeKind, enclosing, envShape, Move(data.get()));
+ Scope* scope = Scope::create(cx, scopeKind, enclosing, envShape, std::move(data.get()));
if (!scope)
return nullptr;
return &scope->as<EvalScope>();
}
/* static */ Scope*
EvalScope::nearestVarScopeForDirectEval(Scope* scope)
{
@@ -1191,17 +1191,17 @@ ModuleScope::createWithData(JSContext* c
Scope* scope = Scope::create(cx, ScopeKind::Module, enclosing, envShape);
if (!scope)
return nullptr;
data->module.init(module);
moduleScope = &scope->as<ModuleScope>();
- moduleScope->initData(Move(data.get()));
+ moduleScope->initData(std::move(data.get()));
}
return moduleScope;
}
/* static */ Shape*
ModuleScope::getEmptyEnvironmentShape(JSContext* cx)
{
@@ -1277,17 +1277,17 @@ WasmInstanceScope::create(JSContext* cx,
Rooted<Scope*> enclosingScope(cx, &cx->global()->emptyGlobalScope());
Scope* scope = Scope::create(cx, ScopeKind::WasmInstance, enclosingScope, /* envShape = */ nullptr);
if (!scope)
return nullptr;
wasmInstanceScope = &scope->as<WasmInstanceScope>();
- wasmInstanceScope->initData(Move(data.get()));
+ wasmInstanceScope->initData(std::move(data.get()));
}
return wasmInstanceScope;
}
/* static */ Shape*
WasmInstanceScope::getEmptyEnvironmentShape(JSContext* cx)
{
@@ -1330,17 +1330,17 @@ WasmFunctionScope::create(JSContext* cx,
new (&data->trailingNames[i]) BindingName(name, false);
}
Scope* scope = Scope::create(cx, ScopeKind::WasmFunction, enclosing, /* envShape = */ nullptr);
if (!scope)
return nullptr;
wasmFunctionScope = &scope->as<WasmFunctionScope>();
- wasmFunctionScope->initData(Move(data.get()));
+ wasmFunctionScope->initData(std::move(data.get()));
return wasmFunctionScope;
}
/* static */ Shape*
WasmFunctionScope::getEmptyEnvironmentShape(JSContext* cx)
{
const Class* cls = &WasmFunctionCallObject::class_;
--- a/js/src/vm/SelfHosting.cpp
+++ b/js/src/vm/SelfHosting.cpp
@@ -298,17 +298,17 @@ ThrowErrorWithType(JSContext* cx, JSExnT
return;
errorArgs[i - 1].encodeLatin1(cx, str);
} else if (val.isString()) {
errorArgs[i - 1].encodeLatin1(cx, val.toString());
} else {
UniqueChars bytes = DecompileValueGenerator(cx, JSDVG_SEARCH_STACK, val, nullptr);
if (!bytes)
return;
- errorArgs[i - 1].initBytes(Move(bytes));
+ errorArgs[i - 1].initBytes(std::move(bytes));
}
if (!errorArgs[i - 1])
return;
}
JS_ReportErrorNumberLatin1(cx, GetErrorMessage, nullptr, errorNumber,
errorArgs[0].ptr(), errorArgs[1].ptr(), errorArgs[2].ptr());
}
--- a/js/src/vm/SharedImmutableStringsCache-inl.h
+++ b/js/src/vm/SharedImmutableStringsCache-inl.h
@@ -26,18 +26,18 @@ SharedImmutableStringsCache::getOrCreate
auto entry = locked->set.lookupForAdd(lookup);
if (!entry) {
OwnedChars ownedChars(intoOwnedChars());
if (!ownedChars)
return mozilla::Nothing();
MOZ_ASSERT(ownedChars.get() == chars ||
memcmp(ownedChars.get(), chars, length) == 0);
- auto box = StringBox::Create(mozilla::Move(ownedChars), length);
- if (!box || !locked->set.add(entry, mozilla::Move(box)))
+ auto box = StringBox::Create(std::move(ownedChars), length);
+ if (!box || !locked->set.add(entry, std::move(box)))
return mozilla::Nothing();
}
MOZ_ASSERT(entry && *entry);
return mozilla::Some(SharedImmutableString(locked, entry->get()));
}
template <typename IntoOwnedTwoByteChars>
@@ -57,18 +57,18 @@ SharedImmutableStringsCache::getOrCreate
auto entry = locked->set.lookupForAdd(lookup);
if (!entry) {
OwnedTwoByteChars ownedTwoByteChars(intoOwnedTwoByteChars());
if (!ownedTwoByteChars)
return mozilla::Nothing();
MOZ_ASSERT(ownedTwoByteChars.get() == chars ||
memcmp(ownedTwoByteChars.get(), chars, length * sizeof(char16_t)) == 0);
OwnedChars ownedChars(reinterpret_cast<char*>(ownedTwoByteChars.release()));
- auto box = StringBox::Create(mozilla::Move(ownedChars), length * sizeof(char16_t));
- if (!box || !locked->set.add(entry, mozilla::Move(box)))
+ auto box = StringBox::Create(std::move(ownedChars), length * sizeof(char16_t));
+ if (!box || !locked->set.add(entry, std::move(box)))
return mozilla::Nothing();
}
MOZ_ASSERT(entry && *entry);
return mozilla::Some(SharedImmutableTwoByteString(locked, entry->get()));
}
} // namespace js
--- a/js/src/vm/SharedImmutableStringsCache.cpp
+++ b/js/src/vm/SharedImmutableStringsCache.cpp
@@ -17,56 +17,56 @@ SharedImmutableString::SharedImmutableSt
: cache_(locked)
, box_(box)
{
MOZ_ASSERT(box);
box->refcount++;
}
SharedImmutableString::SharedImmutableString(SharedImmutableString&& rhs)
- : cache_(mozilla::Move(rhs.cache_))
+ : cache_(std::move(rhs.cache_))
, box_(rhs.box_)
{
MOZ_ASSERT(this != &rhs, "self move not allowed");
MOZ_ASSERT(rhs.box_);
MOZ_ASSERT(rhs.box_->refcount > 0);
rhs.box_ = nullptr;
}
SharedImmutableString&
SharedImmutableString::operator=(SharedImmutableString&& rhs) {
this->~SharedImmutableString();
- new (this) SharedImmutableString(mozilla::Move(rhs));
+ new (this) SharedImmutableString(std::move(rhs));
return *this;
}
SharedImmutableTwoByteString::SharedImmutableTwoByteString(SharedImmutableString&& string)
- : string_(mozilla::Move(string))
+ : string_(std::move(string))
{ }
SharedImmutableTwoByteString::SharedImmutableTwoByteString(
ExclusiveData<SharedImmutableStringsCache::Inner>::Guard& locked,
SharedImmutableStringsCache::StringBox* box)
: string_(locked, box)
{
MOZ_ASSERT(box->length() % sizeof(char16_t) == 0);
}
SharedImmutableTwoByteString::SharedImmutableTwoByteString(SharedImmutableTwoByteString&& rhs)
- : string_(mozilla::Move(rhs.string_))
+ : string_(std::move(rhs.string_))
{
MOZ_ASSERT(this != &rhs, "self move not allowed");
}
SharedImmutableTwoByteString&
SharedImmutableTwoByteString::operator=(SharedImmutableTwoByteString&& rhs)
{
this->~SharedImmutableTwoByteString();
- new (this) SharedImmutableTwoByteString(mozilla::Move(rhs));
+ new (this) SharedImmutableTwoByteString(std::move(rhs));
return *this;
}
SharedImmutableString::~SharedImmutableString() {
if (!box_)
return;
auto locked = cache_.inner_->lock();
@@ -91,33 +91,33 @@ SharedImmutableTwoByteString
SharedImmutableTwoByteString::clone() const
{
return SharedImmutableTwoByteString(string_.clone());
}
MOZ_MUST_USE mozilla::Maybe<SharedImmutableString>
SharedImmutableStringsCache::getOrCreate(OwnedChars&& chars, size_t length)
{
- OwnedChars owned(mozilla::Move(chars));
+ OwnedChars owned(std::move(chars));
MOZ_ASSERT(owned);
- return getOrCreate(owned.get(), length, [&]() { return mozilla::Move(owned); });
+ return getOrCreate(owned.get(), length, [&]() { return std::move(owned); });
}
MOZ_MUST_USE mozilla::Maybe<SharedImmutableString>
SharedImmutableStringsCache::getOrCreate(const char* chars, size_t length)
{
return getOrCreate(chars, length, [&]() { return DuplicateString(chars, length); });
}
MOZ_MUST_USE mozilla::Maybe<SharedImmutableTwoByteString>
SharedImmutableStringsCache::getOrCreate(OwnedTwoByteChars&& chars, size_t length)
{
- OwnedTwoByteChars owned(mozilla::Move(chars));
+ OwnedTwoByteChars owned(std::move(chars));
MOZ_ASSERT(owned);
- return getOrCreate(owned.get(), length, [&]() { return mozilla::Move(owned); });
+ return getOrCreate(owned.get(), length, [&]() { return std::move(owned); });
}
MOZ_MUST_USE mozilla::Maybe<SharedImmutableTwoByteString>
SharedImmutableStringsCache::getOrCreate(const char16_t* chars, size_t length)
{
return getOrCreate(chars, length, [&]() { return DuplicateString(chars, length); });
}
--- a/js/src/vm/SharedImmutableStringsCache.h
+++ b/js/src/vm/SharedImmutableStringsCache.h
@@ -171,17 +171,17 @@ class SharedImmutableStringsCache
: inner_(rhs.inner_)
{
MOZ_ASSERT(inner_);
rhs.inner_ = nullptr;
}
SharedImmutableStringsCache& operator=(SharedImmutableStringsCache&& rhs) {
MOZ_ASSERT(this != &rhs, "self move not allowed");
- new (this) SharedImmutableStringsCache(mozilla::Move(rhs));
+ new (this) SharedImmutableStringsCache(std::move(rhs));
return *this;
}
SharedImmutableStringsCache& operator=(const SharedImmutableStringsCache&) = delete;
SharedImmutableStringsCache clone() {
MOZ_ASSERT(inner_);
auto locked = inner_->lock();
@@ -237,25 +237,25 @@ class SharedImmutableStringsCache
size_t length_;
public:
mutable size_t refcount;
using Ptr = mozilla::UniquePtr<StringBox, JS::DeletePolicy<StringBox>>;
StringBox(OwnedChars&& chars, size_t length)
- : chars_(mozilla::Move(chars))
+ : chars_(std::move(chars))
, length_(length)
, refcount(0)
{
MOZ_ASSERT(chars_);
}
static Ptr Create(OwnedChars&& chars, size_t length) {
- return Ptr(js_new<StringBox>(mozilla::Move(chars), length));
+ return Ptr(js_new<StringBox>(std::move(chars), length));
}
StringBox(const StringBox&) = delete;
StringBox& operator=(const StringBox&) = delete;
~StringBox() {
MOZ_RELEASE_ASSERT(refcount == 0,
"There are `SharedImmutable[TwoByte]String`s outliving their "
--- a/js/src/vm/Stack.cpp
+++ b/js/src/vm/Stack.cpp
@@ -1654,17 +1654,17 @@ jit::JitActivation::getRematerializedFra
// Frames are often rematerialized with the cx inside a Debugger's
// realm. To recover slots and to create CallObjects, we need to
// be in the script's realm.
AutoRealmUnchecked ar(cx, iter.script()->realm());
if (!RematerializedFrame::RematerializeInlineFrames(cx, top, inlineIter, recover, frames))
return nullptr;
- if (!rematerializedFrames_->add(p, top, Move(frames))) {
+ if (!rematerializedFrames_->add(p, top, std::move(frames))) {
ReportOutOfMemory(cx);
return nullptr;
}
// See comment in unsetPrevUpToDateUntil.
DebugEnvironments::unsetPrevUpToDateUntil(cx, p->value()[inlineDepth]);
}
@@ -1704,17 +1704,17 @@ jit::JitActivation::traceRematerializedF
e.front().value().trace(trc);
}
bool
jit::JitActivation::registerIonFrameRecovery(RInstructionResults&& results)
{
// Check that there is no entry in the vector yet.
MOZ_ASSERT(!maybeIonFrameRecovery(results.frame()));
- if (!ionRecovery_.append(mozilla::Move(results)))
+ if (!ionRecovery_.append(std::move(results)))
return false;
return true;
}
jit::RInstructionResults*
jit::JitActivation::maybeIonFrameRecovery(JitFrameLayout* fp)
{
--- a/js/src/vm/Stopwatch.cpp
+++ b/js/src/vm/Stopwatch.cpp
@@ -148,17 +148,17 @@ PerformanceMonitoring::commit()
if (startedAtIteration_ != iteration_) {
// No JS code has been monitored during this iteration.
return true;
}
// The move operation is generally constant time, unless
// `recentGroups_.length()` is very small, in which case
// it's fast just because it's small.
- PerformanceGroupVector recentGroups(Move(recentGroups_));
+ PerformanceGroupVector recentGroups(std::move(recentGroups_));
recentGroups_ = PerformanceGroupVector(); // Reconstruct after `Move`.
bool success = true;
if (stopwatchCommitCallback)
success = stopwatchCommitCallback(iteration_, recentGroups, stopwatchCommitClosure);
// Heuristic: we expect to have roughly the same number of groups as in
// the previous iteration.
--- a/js/src/vm/StructuredClone.cpp
+++ b/js/src/vm/StructuredClone.cpp
@@ -229,17 +229,17 @@ struct BufferIterator {
const BufferList& mBuffer;
typename BufferList::IterImpl mIter;
};
SharedArrayRawBufferRefs&
SharedArrayRawBufferRefs::operator=(SharedArrayRawBufferRefs&& other)
{
- takeOwnership(Move(other));
+ takeOwnership(std::move(other));
return *this;
}
SharedArrayRawBufferRefs::~SharedArrayRawBufferRefs()
{
releaseAll();
}
@@ -278,17 +278,17 @@ SharedArrayRawBufferRefs::acquireAll(JSC
return true;
}
void
SharedArrayRawBufferRefs::takeOwnership(SharedArrayRawBufferRefs&& other)
{
MOZ_ASSERT(refs_.empty());
- refs_ = Move(other.refs_);
+ refs_ = std::move(other.refs_);
}
void
SharedArrayRawBufferRefs::releaseAll()
{
for (auto ref : refs_)
ref->dropReference();
refs_.clear();
@@ -323,17 +323,17 @@ struct SCOutput {
MOZ_MUST_USE bool writeArray(const T* p, size_t nbytes);
void setCallbacks(const JSStructuredCloneCallbacks* callbacks,
void* closure,
OwnTransferablePolicy policy)
{
buf.setCallbacks(callbacks, closure, policy);
}
- void extractBuffer(JSStructuredCloneData* data) { *data = Move(buf); }
+ void extractBuffer(JSStructuredCloneData* data) { *data = std::move(buf); }
void discardTransferables();
uint64_t tell() const { return buf.Size(); }
uint64_t count() const { return buf.Size() / sizeof(uint64_t); }
Iter iter() { return Iter(buf); }
size_t offset(Iter dest) {
return dest - iter();
@@ -2838,33 +2838,33 @@ JSAutoStructuredCloneBuffer::clear()
}
void
JSAutoStructuredCloneBuffer::adopt(JSStructuredCloneData&& data, uint32_t version,
const JSStructuredCloneCallbacks* callbacks,
void* closure)
{
clear();
- data_ = Move(data);
+ data_ = std::move(data);
version_ = version;
data_.setCallbacks(callbacks, closure, OwnTransferablePolicy::OwnsTransferablesIfAny);
}
void
JSAutoStructuredCloneBuffer::steal(JSStructuredCloneData* data, uint32_t* versionp,
const JSStructuredCloneCallbacks** callbacks,
void** closure)
{
if (versionp)
*versionp = version_;
if (callbacks)
*callbacks = data_.callbacks_;
if (closure)
*closure = data_.closure_;
- *data = Move(data_);
+ *data = std::move(data_);
version_ = 0;
data_.setCallbacks(nullptr, nullptr, OwnTransferablePolicy::NoTransferables);
}
bool
JSAutoStructuredCloneBuffer::read(JSContext* cx, MutableHandleValue vp,
const JSStructuredCloneCallbacks* optionalCallbacks,
--- a/js/src/vm/TypeInference.cpp
+++ b/js/src/vm/TypeInference.cpp
@@ -2558,17 +2558,17 @@ js::ClassCanHaveExtraProperties(const Cl
void
TypeZone::processPendingRecompiles(FreeOp* fop, RecompileInfoVector& recompiles)
{
MOZ_ASSERT(!recompiles.empty());
// Steal the list of scripts to recompile, to make sure we don't try to
// recursively recompile them. Note: the move constructor will not reset the
// length if the Vector is using inline storage, so we also use clear().
- RecompileInfoVector pending(Move(recompiles));
+ RecompileInfoVector pending(std::move(recompiles));
recompiles.clear();
jit::Invalidate(*this, fop, pending);
MOZ_ASSERT(recompiles.empty());
}
void
--- a/js/src/vm/UbiNode.cpp
+++ b/js/src/vm/UbiNode.cpp
@@ -261,17 +261,17 @@ class EdgeVectorTracer : public JS::Call
name16[i] = name[i];
name16[i] = '\0';
}
// The simplest code is correct! The temporary Edge takes
// ownership of name; if the append succeeds, the vector element
// then takes ownership; if the append fails, then the temporary
// retains it, and its destructor will free it.
- if (!vec->append(mozilla::Move(Edge(name16, Node(thing))))) {
+ if (!vec->append(std::move(Edge(name16, Node(thing))))) {
okay = false;
return;
}
}
public:
// True if no errors (OOM, say) have yet occurred.
bool okay;
@@ -469,17 +469,17 @@ RootList::init(CompartmentSet& debuggees
JSCompartment* compartment = edge.referent.compartment();
if (compartment && !debuggees.has(compartment))
continue;
Zone* zone = edge.referent.zone();
if (zone && !debuggeeZones.has(zone))
continue;
- if (!edges.append(mozilla::Move(edge)))
+ if (!edges.append(std::move(edge)))
return false;
}
noGC.emplace();
return true;
}
bool
@@ -520,17 +520,17 @@ RootList::addRoot(Node node, const char1
UniqueTwoByteChars name;
if (edgeName) {
name = js::DuplicateString(edgeName);
if (!name)
return false;
}
- return edges.append(mozilla::Move(Edge(name.release(), node)));
+ return edges.append(std::move(Edge(name.release(), node)));
}
const char16_t Concrete<RootList>::concreteTypeName[] = u"JS::ubi::RootList";
UniquePtr<EdgeRange>
Concrete<RootList>::edges(JSContext* cx, bool wantNames) const {
MOZ_ASSERT_IF(wantNames, get().wantNames);
return UniquePtr<EdgeRange>(js_new<PreComputedEdgeRange>(get().edges));
--- a/js/src/vm/UbiNodeCensus.cpp
+++ b/js/src/vm/UbiNodeCensus.cpp
@@ -54,17 +54,17 @@ class SimpleCount : public CountType {
bool reportCount : 1;
bool reportBytes : 1;
public:
explicit SimpleCount(UniqueTwoByteChars& label,
bool reportCount=true,
bool reportBytes=true)
: CountType(),
- label(Move(label)),
+ label(std::move(label)),
reportCount(reportCount),
reportBytes(reportBytes)
{ }
explicit SimpleCount()
: CountType(),
label(nullptr),
reportCount(true),
@@ -190,38 +190,38 @@ class ByCoarseType : public CountType {
struct Count : CountBase {
Count(CountType& type,
CountBasePtr& objects,
CountBasePtr& scripts,
CountBasePtr& strings,
CountBasePtr& other)
: CountBase(type),
- objects(Move(objects)),
- scripts(Move(scripts)),
- strings(Move(strings)),
- other(Move(other))
+ objects(std::move(objects)),
+ scripts(std::move(scripts)),
+ strings(std::move(strings)),
+ other(std::move(other))
{ }
CountBasePtr objects;
CountBasePtr scripts;
CountBasePtr strings;
CountBasePtr other;
};
public:
ByCoarseType(CountTypePtr& objects,
CountTypePtr& scripts,
CountTypePtr& strings,
CountTypePtr& other)
: CountType(),
- objects(Move(objects)),
- scripts(Move(scripts)),
- strings(Move(strings)),
- other(Move(other))
+ objects(std::move(objects)),
+ scripts(std::move(scripts)),
+ strings(std::move(strings)),
+ other(std::move(other))
{ }
void destructCount(CountBase& countBase) override {
Count& count = static_cast<Count&>(countBase);
count.~Count();
}
CountBasePtr makeCount() override;
@@ -399,30 +399,30 @@ class ByObjectClass : public CountType {
using Entry = Table::Entry;
struct Count : public CountBase {
Table table;
CountBasePtr other;
Count(CountType& type, CountBasePtr& other)
: CountBase(type),
- other(Move(other))
+ other(std::move(other))
{ }
bool init() { return table.init(); }
};
CountTypePtr classesType;
CountTypePtr otherType;
public:
ByObjectClass(CountTypePtr& classesType, CountTypePtr& otherType)
: CountType(),
- classesType(Move(classesType)),
- otherType(Move(otherType))
+ classesType(std::move(classesType)),
+ otherType(std::move(otherType))
{ }
void destructCount(CountBase& countBase) override {
Count& count = static_cast<Count&>(countBase);
count.~Count();
}
CountBasePtr makeCount() override;
@@ -461,17 +461,17 @@ ByObjectClass::count(CountBase& countBas
const char* className = node.jsObjectClassName();
if (!className)
return count.other->count(mallocSizeOf, node);
Table::AddPtr p = count.table.lookupForAdd(className);
if (!p) {
CountBasePtr classCount(classesType->makeCount());
- if (!classCount || !count.table.add(p, className, Move(classCount)))
+ if (!classCount || !count.table.add(p, className, std::move(classCount)))
return false;
}
return p->value()->count(mallocSizeOf, node);
}
bool
ByObjectClass::report(JSContext* cx, CountBase& countBase, MutableHandleValue report)
{
@@ -510,17 +510,17 @@ class ByUbinodeType : public CountType {
bool init() { return table.init(); }
};
CountTypePtr entryType;
public:
explicit ByUbinodeType(CountTypePtr& entryType)
: CountType(),
- entryType(Move(entryType))
+ entryType(std::move(entryType))
{ }
void destructCount(CountBase& countBase) override {
Count& count = static_cast<Count&>(countBase);
count.~Count();
}
CountBasePtr makeCount() override;
@@ -552,17 +552,17 @@ ByUbinodeType::count(CountBase& countBas
{
Count& count = static_cast<Count&>(countBase);
const char16_t* key = node.typeName();
MOZ_ASSERT(key);
Table::AddPtr p = count.table.lookupForAdd(key);
if (!p) {
CountBasePtr typesCount(entryType->makeCount());
- if (!typesCount || !count.table.add(p, key, Move(typesCount)))
+ if (!typesCount || !count.table.add(p, key, std::move(typesCount)))
return false;
}
return p->value()->count(mallocSizeOf, node);
}
bool
ByUbinodeType::report(JSContext* cx, CountBase& countBase, MutableHandleValue report)
{
@@ -641,29 +641,29 @@ class ByAllocationStack : public CountTy
//
// So depending on the phase, we either don't need re-keying, or
// can't abide it.
Table table;
CountBasePtr noStack;
Count(CountType& type, CountBasePtr& noStack)
: CountBase(type),
- noStack(Move(noStack))
+ noStack(std::move(noStack))
{ }
bool init() { return table.init(); }
};
CountTypePtr entryType;
CountTypePtr noStackType;
public:
ByAllocationStack(CountTypePtr& entryType, CountTypePtr& noStackType)
: CountType(),
- entryType(Move(entryType)),
- noStackType(Move(noStackType))
+ entryType(std::move(entryType)),
+ noStackType(std::move(noStackType))
{ }
void destructCount(CountBase& countBase) override {
Count& count = static_cast<Count&>(countBase);
count.~Count();
}
CountBasePtr makeCount() override;
@@ -709,17 +709,17 @@ ByAllocationStack::count(CountBase& coun
// If we do have an allocation stack for this node, include it in the
// count for that stack.
if (node.hasAllocationStack()) {
auto allocationStack = node.allocationStack();
auto p = count.table.lookupForAdd(allocationStack);
if (!p) {
CountBasePtr stackCount(entryType->makeCount());
- if (!stackCount || !count.table.add(p, allocationStack, Move(stackCount)))
+ if (!stackCount || !count.table.add(p, allocationStack, std::move(stackCount)))
return false;
}
MOZ_ASSERT(p);
return p->value()->count(mallocSizeOf, node);
}
// Otherwise, count it in the "no stack" category.
return count.noStack->count(mallocSizeOf, node);
@@ -811,31 +811,31 @@ class ByFilename : public CountType {
struct Count : public CountBase {
Table table;
CountBasePtr then;
CountBasePtr noFilename;
Count(CountType& type, CountBasePtr&& then, CountBasePtr&& noFilename)
: CountBase(type)
- , then(Move(then))
- , noFilename(Move(noFilename))
+ , then(std::move(then))
+ , noFilename(std::move(noFilename))
{ }
bool init() { return table.init(); }
};
CountTypePtr thenType;
CountTypePtr noFilenameType;
public:
ByFilename(CountTypePtr&& thenType, CountTypePtr&& noFilenameType)
: CountType(),
- thenType(Move(thenType)),
- noFilenameType(Move(noFilenameType))
+ thenType(std::move(thenType)),
+ noFilenameType(std::move(noFilenameType))
{ }
void destructCount(CountBase& countBase) override {
Count& count = static_cast<Count&>(countBase);
count.~Count();
}
CountBasePtr makeCount() override;
@@ -850,17 +850,17 @@ ByFilename::makeCount()
CountBasePtr thenCount(thenType->makeCount());
if (!thenCount)
return nullptr;
CountBasePtr noFilenameCount(noFilenameType->makeCount());
if (!noFilenameCount)
return nullptr;
- UniquePtr<Count> count(js_new<Count>(*this, Move(thenCount), Move(noFilenameCount)));
+ UniquePtr<Count> count(js_new<Count>(*this, std::move(thenCount), std::move(noFilenameCount)));
if (!count || !count->init())
return nullptr;
return CountBasePtr(count.release());
}
void
ByFilename::traceCount(CountBase& countBase, JSTracer* trc)
@@ -882,17 +882,17 @@ ByFilename::count(CountBase& countBase,
UniqueCString myFilename(js_strdup(filename));
if (!myFilename)
return false;
Table::AddPtr p = count.table.lookupForAdd(myFilename);
if (!p) {
CountBasePtr thenCount(thenType->makeCount());
- if (!thenCount || !count.table.add(p, Move(myFilename), Move(thenCount)))
+ if (!thenCount || !count.table.add(p, std::move(myFilename), std::move(thenCount)))
return false;
}
return p->value()->count(mallocSizeOf, node);
}
bool
ByFilename::report(JSContext* cx, CountBase& countBase, MutableHandleValue report)
{
@@ -1088,17 +1088,17 @@ ParseBreakdown(JSContext* cx, HandleValu
CountTypePtr thenType(ParseChildBreakdown(cx, breakdown, cx->names().then));
if (!thenType)
return nullptr;
CountTypePtr noFilenameType(ParseChildBreakdown(cx, breakdown, cx->names().noFilename));
if (!noFilenameType)
return nullptr;
- return CountTypePtr(cx->new_<ByFilename>(Move(thenType), Move(noFilenameType)));
+ return CountTypePtr(cx->new_<ByFilename>(std::move(thenType), std::move(noFilenameType)));
}
// We didn't recognize the breakdown type; complain.
RootedString bySource(cx, ValueToSource(cx, byValue));
if (!bySource)
return nullptr;
JSAutoByteString byBytes(cx, bySource);
--- a/js/src/vm/UbiNodeShortestPaths.cpp
+++ b/js/src/vm/UbiNodeShortestPaths.cpp
@@ -23,17 +23,17 @@ BackEdge::clone() const
return nullptr;
clone->predecessor_ = predecessor();
if (name()) {
clone->name_ = js::DuplicateString(name().get());
if (!clone->name_)
return nullptr;
}
- return mozilla::Move(clone);
+ return std::move(clone);
}
#ifdef DEBUG
static void
dumpNode(const JS::ubi::Node& node)
{
fprintf(stderr, " %p ", (void*) node.identifier());
@@ -52,17 +52,17 @@ dumpPaths(JSContext* cx, Node node, uint
JS::ubi::RootList rootList(cx, nogc, true);
MOZ_ASSERT(rootList.init());
NodeSet targets;
bool ok = targets.init() && targets.putNew(node);
MOZ_ASSERT(ok);
- auto paths = ShortestPaths::Create(cx, nogc.ref(), maxNumPaths, &rootList, mozilla::Move(targets));
+ auto paths = ShortestPaths::Create(cx, nogc.ref(), maxNumPaths, &rootList, std::move(targets));
MOZ_ASSERT(paths.isSome());
int i = 0;
ok = paths->forEachPath(node, [&](Path& path) {
fprintf(stderr, "Path %d:\n", i++);
for (auto backEdge : path) {
dumpNode(backEdge->predecessor());
fprintf(stderr, " |\n");
--- a/js/src/vm/Xdr.cpp
+++ b/js/src/vm/Xdr.cpp
@@ -275,23 +275,23 @@ XDRIncrementalEncoder::createOrReplaceSu
uint32_t(child->key_) <= uint32_t(parent->key_));
}
// Create or replace the part with what is going to be encoded next.
SlicesTree::AddPtr p = tree_.lookupForAdd(child->key_);
SlicesNode tmp;
if (!p) {
// Create a new sub-tree node.
- if (!tree_.add(p, child->key_, mozilla::Move(tmp))) {
+ if (!tree_.add(p, child->key_, std::move(tmp))) {
oom_ = true;
return;
}
} else {
// Replace an exisiting sub-tree.
- p->value() = mozilla::Move(tmp);
+ p->value() = std::move(tmp);
}
node_ = &p->value();
// Add content to the root of the new sub-tree,
// i-e an empty slice with no children.
if (!node_->append(Slice { cursor, 0, AutoXDRTree::noSubTree }))
MOZ_CRASH("SlicesNode have a reserved space of 1.");
}
--- a/js/src/wasm/AsmJS.cpp
+++ b/js/src/wasm/AsmJS.cpp
@@ -162,17 +162,17 @@ class AsmJSGlobal
friend class ModuleValidator;
public:
AsmJSGlobal() = default;
AsmJSGlobal(Which which, UniqueChars field) {
mozilla::PodZero(&pod); // zero padding for Valgrind
pod.which_ = which;
- field_ = Move(field);
+ field_ = std::move(field);
}
const char* field() const {
return field_.get();
}
Which which() const {
return pod.which_;
}
VarInitKind varInitKind() const {
@@ -1417,18 +1417,18 @@ class MOZ_STACK_CLASS ModuleValidator
uint32_t funcDefIndex() const { return funcDefIndex_; }
void define(ParseNode* fn, uint32_t line, Bytes&& bytes, Uint32Vector&& callSiteLineNums) {
MOZ_ASSERT(!defined_);
defined_ = true;
srcBegin_ = fn->pn_pos.begin;
srcEnd_ = fn->pn_pos.end;
line_ = line;
- bytes_ = Move(bytes);
- callSiteLineNums_ = Move(callSiteLineNums);
+ bytes_ = std::move(bytes);
+ callSiteLineNums_ = std::move(callSiteLineNums);
}
uint32_t srcBegin() const { MOZ_ASSERT(defined_); return srcBegin_; }
uint32_t srcEnd() const { MOZ_ASSERT(defined_); return srcEnd_; }
uint32_t line() const { MOZ_ASSERT(defined_); return line_; }
const Bytes& bytes() const { MOZ_ASSERT(defined_); return bytes_; }
Uint32Vector& callSiteLineNums() { MOZ_ASSERT(defined_); return callSiteLineNums_; }
};
@@ -1755,27 +1755,27 @@ class MOZ_STACK_CLASS ModuleValidator
return false;
return standardLibrarySimdOpNames_.putNew(atom->asPropertyName(), op);
}
bool newSig(Sig&& sig, uint32_t* sigIndex) {
if (env_.sigs.length() >= MaxTypes)
return failCurrentOffset("too many signatures");
*sigIndex = env_.sigs.length();
- return env_.sigs.append(Move(sig));
+ return env_.sigs.append(std::move(sig));
}
bool declareSig(Sig&& sig, uint32_t* sigIndex) {
SigSet::AddPtr p = sigSet_.lookupForAdd(sig);
if (p) {
*sigIndex = p->sigIndex();
MOZ_ASSERT(env_.sigs[*sigIndex] == sig);
return true;
}
- return newSig(Move(sig), sigIndex) &&
+ return newSig(std::move(sig), sigIndex) &&
sigSet_.add(p, HashableSig(*sigIndex, env_.sigs));
}
public:
ModuleValidator(JSContext* cx, AsmJSParser& parser, ParseNode* moduleFunctionNode)
: cx_(cx),
parser_(parser),
moduleFunctionNode_(moduleFunctionNode),
@@ -1821,28 +1821,28 @@ class MOZ_STACK_CLASS ModuleValidator
void typeFailure(uint32_t offset, ...) {
va_list args;
va_start(args, offset);
auto& ts = tokenStream();
ErrorMetadata metadata;
if (ts.computeErrorMetadata(&metadata, offset)) {
if (ts.anyCharsAccess().options().throwOnAsmJSValidationFailureOption) {
- ReportCompileError(cx_, Move(metadata), nullptr, JSREPORT_ERROR,
+ ReportCompileError(cx_, std::move(metadata), nullptr, JSREPORT_ERROR,
JSMSG_USE_ASM_TYPE_FAIL, args);
} else {
// asm.js type failure is indicated by calling one of the fail*
// functions below. These functions always return false to
// halt asm.js parsing. Whether normal parsing is attempted as
// fallback, depends whether an exception is also set.
//
// If warning succeeds, no exception is set. If warning fails,
// an exception is set and execution will halt. Thus it's safe
// and correct to ignore the return value here.
- Unused << ts.anyCharsAccess().compileWarning(Move(metadata), nullptr,
+ Unused << ts.anyCharsAccess().compileWarning(std::move(metadata), nullptr,
JSREPORT_WARNING,
JSMSG_USE_ASM_TYPE_FAIL, args);
}
}
va_end(args);
}
@@ -2000,17 +2000,17 @@ class MOZ_STACK_CLASS ModuleValidator
else
new (&global->u.varOrConst) Global::U::VarOrConst(index, type.which());
if (!globalMap_.putNew(var, global))
return false;
AsmJSGlobal g(AsmJSGlobal::Variable, nullptr);
g.pod.u.var.initKind_ = AsmJSGlobal::InitConstant;
g.pod.u.var.u.val_ = lit.value();
- return asmJSMetadata_->asmJSGlobals.append(Move(g));
+ return asmJSMetadata_->asmJSGlobals.append(std::move(g));
}
bool addGlobalVarImport(PropertyName* var, PropertyName* field, Type type, bool isConst) {
MOZ_ASSERT(type.isGlobalVarType());
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
if (!fieldChars)
return false;
@@ -2022,20 +2022,20 @@ class MOZ_STACK_CLASS ModuleValidator
Global::Which which = isConst ? Global::ConstantImport : Global::Variable;
Global* global = validationLifo_.new_<Global>(which);
if (!global)
return false;
new (&global->u.varOrConst) Global::U::VarOrConst(index, type.which());
if (!globalMap_.putNew(var, global))
return false;
- AsmJSGlobal g(AsmJSGlobal::Variable, Move(fieldChars));
+ AsmJSGlobal g(AsmJSGlobal::Variable, std::move(fieldChars));
g.pod.u.var.initKind_ = AsmJSGlobal::InitImport;
g.pod.u.var.u.importType_ = valType;
- return asmJSMetadata_->asmJSGlobals.append(Move(g));
+ return asmJSMetadata_->asmJSGlobals.append(std::move(g));
}
bool addArrayView(PropertyName* var, Scalar::Type vt, PropertyName* maybeField) {
UniqueChars fieldChars;
if (maybeField) {
fieldChars = StringToNewUTF8CharsZ(cx_, *maybeField);
if (!fieldChars)
return false;
}
@@ -2045,37 +2045,37 @@ class MOZ_STACK_CLASS ModuleValidator
Global* global = validationLifo_.new_<Global>(Global::ArrayView);
if (!global)
return false;
new (&global->u.viewType_) Scalar::Type(vt);
if (!globalMap_.putNew(var, global))
return false;
- AsmJSGlobal g(AsmJSGlobal::ArrayView, Move(fieldChars));
+ AsmJSGlobal g(AsmJSGlobal::ArrayView, std::move(fieldChars));
g.pod.u.viewType_ = vt;
- return asmJSMetadata_->asmJSGlobals.append(Move(g));
+ return asmJSMetadata_->asmJSGlobals.append(std::move(g));
}
bool addMathBuiltinFunction(PropertyName* var, AsmJSMathBuiltinFunction func,
PropertyName* field)
{
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
if (!fieldChars)
return false;
Global* global = validationLifo_.new_<Global>(Global::MathBuiltinFunction);
if (!global)
return false;
new (&global->u.mathBuiltinFunc_) AsmJSMathBuiltinFunction(func);
if (!globalMap_.putNew(var, global))
return false;
- AsmJSGlobal g(AsmJSGlobal::MathBuiltinFunction, Move(fieldChars));
+ AsmJSGlobal g(AsmJSGlobal::MathBuiltinFunction, std::move(fieldChars));
g.pod.u.mathBuiltinFunc_ = func;
- return asmJSMetadata_->asmJSGlobals.append(Move(g));
+ return asmJSMetadata_->asmJSGlobals.append(std::move(g));
}
private:
bool addGlobalDoubleConstant(PropertyName* var, double constant) {
Global* global = validationLifo_.new_<Global>(Global::ConstantLiteral);
if (!global)
return false;
new (&global->u.varOrConst) Global::U::VarOrConst(constant);
return globalMap_.putNew(var, global);
@@ -2084,33 +2084,33 @@ class MOZ_STACK_CLASS ModuleValidator
bool addMathBuiltinConstant(PropertyName* var, double constant, PropertyName* field) {
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
if (!fieldChars)
return false;
if (!addGlobalDoubleConstant(var, constant))
return false;
- AsmJSGlobal g(AsmJSGlobal::Constant, Move(fieldChars));
+ AsmJSGlobal g(AsmJSGlobal::Constant, std::move(fieldChars));
g.pod.u.constant.value_ = constant;
g.pod.u.constant.kind_ = AsmJSGlobal::MathConstant;
- return asmJSMetadata_->asmJSGlobals.append(Move(g));
+ return asmJSMetadata_->asmJSGlobals.append(std::move(g));
}
bool addGlobalConstant(PropertyName* var, double constant, PropertyName* field) {
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
if (!fieldChars)
return false;
if (!addGlobalDoubleConstant(var, constant))
return false;
- AsmJSGlobal g(AsmJSGlobal::Constant, Move(fieldChars));
+ AsmJSGlobal g(AsmJSGlobal::Constant, std::move(fieldChars));
g.pod.u.constant.value_ = constant;
g.pod.u.constant.kind_ = AsmJSGlobal::GlobalConstant;
- return asmJSMetadata_->asmJSGlobals.append(Move(g));
+ return asmJSMetadata_->asmJSGlobals.append(std::move(g));
}
bool addAtomicsBuiltinFunction(PropertyName* var, AsmJSAtomicsBuiltinFunction func,
PropertyName* field)
{
if (!JitOptions.asmJSAtomicsEnable)
return failCurrentOffset("asm.js Atomics only enabled when asmjs.atomics.enable is set");
atomicsPresent_ = true;
@@ -2121,72 +2121,72 @@ class MOZ_STACK_CLASS ModuleValidator
Global* global = validationLifo_.new_<Global>(Global::AtomicsBuiltinFunction);
if (!global)
return false;
new (&global->u.atomicsBuiltinFunc_) AsmJSAtomicsBuiltinFunction(func);
if (!globalMap_.putNew(var, global))
return false;
- AsmJSGlobal g(AsmJSGlobal::AtomicsBuiltinFunction, Move(fieldChars));
+ AsmJSGlobal g(AsmJSGlobal::AtomicsBuiltinFunction, std::move(fieldChars));
g.pod.u.atomicsBuiltinFunc_ = func;
- return asmJSMetadata_->asmJSGlobals.append(Move(g));
+ return asmJSMetadata_->asmJSGlobals.append(std::move(g));
}
bool addSimdCtor(PropertyName* var, SimdType type, PropertyName* field) {
simdPresent_ = true;
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
if (!fieldChars)
return false;
Global* global = validationLifo_.new_<Global>(Global::SimdCtor);
if (!global)
return false;
new (&global->u.simdCtorType_) SimdType(type);
if (!globalMap_.putNew(var, global))
return false;
- AsmJSGlobal g(AsmJSGlobal::SimdCtor, Move(fieldChars));
+ AsmJSGlobal g(AsmJSGlobal::SimdCtor, std::move(fieldChars));
g.pod.u.simdCtorType_ = type;
- return asmJSMetadata_->asmJSGlobals.append(Move(g));
+ return asmJSMetadata_->asmJSGlobals.append(std::move(g));
}
bool addSimdOperation(PropertyName* var, SimdType type, SimdOperation op, PropertyName* field) {
simdPresent_ = true;
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
if (!fieldChars)
return false;
Global* global = validationLifo_.new_<Global>(Global::SimdOp);
if (!global)
return false;
new (&global->u.simdOp) Global::U::SimdTypeAndOperation{ type, op };
if (!globalMap_.putNew(var, global))
return false;
- AsmJSGlobal g(AsmJSGlobal::SimdOp, Move(fieldChars));
+ AsmJSGlobal g(AsmJSGlobal::SimdOp, std::move(fieldChars));
g.pod.u.simdOp.type_ = type;
g.pod.u.simdOp.which_ = op;
- return asmJSMetadata_->asmJSGlobals.append(Move(g));
+ return asmJSMetadata_->asmJSGlobals.append(std::move(g));
}
bool addArrayViewCtor(PropertyName* var, Scalar::Type vt, PropertyName* field) {
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
if (!fieldChars)
return false;
Global* global = validationLifo_.new_<Global>(Global::ArrayViewCtor);
if (!global)
return false;
new (&global->u.viewType_) Scalar::Type(vt);
if (!globalMap_.putNew(var, global))
return false;
- AsmJSGlobal g(AsmJSGlobal::ArrayViewCtor, Move(fieldChars));
+ AsmJSGlobal g(AsmJSGlobal::ArrayViewCtor, std::move(fieldChars));
g.pod.u.viewType_ = vt;
- return asmJSMetadata_->asmJSGlobals.append(Move(g));
+ return asmJSMetadata_->asmJSGlobals.append(std::move(g));
}
bool addFFI(PropertyName* var, PropertyName* field) {
UniqueChars fieldChars = StringToNewUTF8CharsZ(cx_, *field);
if (!fieldChars)
return false;
if (asmJSMetadata_->numFFIs == UINT32_MAX)
return false;
@@ -2194,45 +2194,45 @@ class MOZ_STACK_CLASS ModuleValidator
Global* global = validationLifo_.new_<Global>(Global::FFI);
if (!global)
return false;
new (&global->u.ffiIndex_) uint32_t(ffiIndex);
if (!globalMap_.putNew(var, global))
return false;
- AsmJSGlobal g(AsmJSGlobal::FFI, Move(fieldChars));
+ AsmJSGlobal g(AsmJSGlobal::FFI, std::move(fieldChars));
g.pod.u.ffiIndex_ = ffiIndex;
- return asmJSMetadata_->asmJSGlobals.append(Move(g));
+ return asmJSMetadata_->asmJSGlobals.append(std::move(g));
}
bool addExportField(const Func& func, PropertyName* maybeField) {
// Record the field name of this export.
CacheableChars fieldChars;
if (maybeField)
fieldChars = StringToNewUTF8CharsZ(cx_, *maybeField);
else
fieldChars = DuplicateString("");
if (!fieldChars)
return false;
// Declare which function is exported which gives us an index into the
// module ExportVector.
uint32_t funcIndex = funcImportMap_.count() + func.funcDefIndex();
- if (!env_.exports.emplaceBack(Move(fieldChars), funcIndex, DefinitionKind::Function))
+ if (!env_.exports.emplaceBack(std::move(fieldChars), funcIndex, DefinitionKind::Function))
return false;
// The exported function might have already been exported in which case
// the index will refer into the range of AsmJSExports.
return asmJSMetadata_->asmJSExports.emplaceBack(funcIndex,
func.srcBegin() - asmJSMetadata_->srcStart,
func.srcEnd() - asmJSMetadata_->srcStart);
}
bool addFuncDef(PropertyName* name, uint32_t firstUse, Sig&& sig, Func** func) {
uint32_t sigIndex;
- if (!declareSig(Move(sig), &sigIndex))
+ if (!declareSig(std::move(sig), &sigIndex))
return false;
uint32_t funcDefIndex = funcDefs_.length();
if (funcDefIndex >= MaxFuncs)
return failCurrentOffset("too many functions");
Global* global = validationLifo_.new_<Global>(Global::Function);
if (!global)
@@ -2250,17 +2250,17 @@ class MOZ_STACK_CLASS ModuleValidator
{
if (mask > MaxTableInitialLength)
return failCurrentOffset("function pointer table too big");
MOZ_ASSERT(env_.tables.length() == tables_.length());
*tableIndex = env_.tables.length();
uint32_t sigIndex;
- if (!newSig(Move(sig), &sigIndex))
+ if (!newSig(std::move(sig), &sigIndex))
return false;
MOZ_ASSERT(sigIndex >= env_.asmJSSigToTableIndex.length());
if (!env_.asmJSSigToTableIndex.resize(sigIndex + 1))
return false;
env_.asmJSSigToTableIndex[sigIndex] = env_.tables.length();
if (!env_.tables.emplaceBack(TableKind::TypedFunction, Limits(mask + 1)))
@@ -2282,17 +2282,17 @@ class MOZ_STACK_CLASS ModuleValidator
if (table.defined())
return false;
table.define();
for (uint32_t& index : elems)
index += funcImportMap_.count();
- return env_.elemSegments.emplaceBack(tableIndex, InitExpr(Val(uint32_t(0))), Move(elems));
+ return env_.elemSegments.emplaceBack(tableIndex, InitExpr(Val(uint32_t(0))), std::move(elems));
}
bool declareImport(PropertyName* name, Sig&& sig, unsigned ffiIndex, uint32_t* importIndex) {
FuncImportMap::AddPtr p = funcImportMap_.lookupForAdd(NamedSig::Lookup(name, sig));
if (p) {
*importIndex = p->value();
return true;
}
@@ -2301,17 +2301,17 @@ class MOZ_STACK_CLASS ModuleValidator
if (*importIndex >= MaxImports)
return failCurrentOffset("too many imports");
if (!asmJSMetadata_->asmJSImports.emplaceBack(ffiIndex))
return false;
uint32_t sigIndex;
- if (!declareSig(Move(sig), &sigIndex))
+ if (!declareSig(std::move(sig), &sigIndex))
return false;
return funcImportMap_.add(p, NamedSig(name, sigIndex, env_.sigs), *importIndex);
}
bool tryConstantAccess(uint64_t start, uint64_t width) {
MOZ_ASSERT(UINT64_MAX - start > width);
uint64_t len = start + width;
@@ -2471,17 +2471,17 @@ class MOZ_STACK_CLASS ModuleValidator
asmJSMetadata_->usesSimd = simdPresent_;
MOZ_ASSERT(asmJSMetadata_->asmJSFuncNames.empty());
if (!asmJSMetadata_->asmJSFuncNames.resize(funcImportMap_.count()))
return nullptr;
for (const Func& func : funcDefs_) {
CacheableChars funcName = StringToNewUTF8CharsZ(cx_, *func.name());
- if (!funcName || !asmJSMetadata_->asmJSFuncNames.emplaceBack(Move(funcName)))
+ if (!funcName || !asmJSMetadata_->asmJSFuncNames.emplaceBack(std::move(funcName)))
return nullptr;
}
uint32_t endBeforeCurly = tokenStream().anyCharsAccess().currentToken().pos.end;
asmJSMetadata_->srcLength = endBeforeCurly - asmJSMetadata_->srcStart;
TokenPos pos;
MOZ_ALWAYS_TRUE(tokenStream().peekTokenPos(&pos, TokenStreamShared::Operand));
@@ -2492,17 +2492,17 @@ class MOZ_STACK_CLASS ModuleValidator
if (parser_.ss->filename()) {
scriptedCaller.line = 0; // unused
scriptedCaller.filename = DuplicateString(parser_.ss->filename());
if (!scriptedCaller.filename)
return nullptr;
}
MutableCompileArgs args = cx_->new_<CompileArgs>();
- if (!args || !args->initFromContext(cx_, Move(scriptedCaller)))
+ if (!args || !args->initFromContext(cx_, std::move(scriptedCaller)))
return nullptr;
uint32_t codeSectionSize = 0;
for (const Func& func : funcDefs_)
codeSectionSize += func.bytes().length();
env_.codeSection.emplace();
env_.codeSection->start = 0;
@@ -2516,17 +2516,17 @@ class MOZ_STACK_CLASS ModuleValidator
ModuleGenerator mg(*args, &env_, nullptr, nullptr);
if (!mg.init(asmJSMetadata_.get()))
return nullptr;
for (Func& func : funcDefs_) {
if (!mg.compileFuncDef(funcImportMap_.count() + func.funcDefIndex(), func.line(),
func.bytes().begin(), func.bytes().end(),
- Move(func.callSiteLineNums()))) {
+ std::move(func.callSiteLineNums()))) {
return nullptr;
}
}
if (!mg.finishFuncDefs())
return nullptr;
return mg.finishModule(*bytes);
@@ -3069,17 +3069,17 @@ class MOZ_STACK_CLASS FunctionValidator
}
void define(ModuleValidator::Func* func, unsigned line) {
MOZ_ASSERT(!blockDepth_);
MOZ_ASSERT(breakableStack_.empty());
MOZ_ASSERT(continuableStack_.empty());
MOZ_ASSERT(breakLabels_.empty());
MOZ_ASSERT(continueLabels_.empty());
- func->define(fn_, line, Move(bytes_), Move(callSiteLineNums_));
+ func->define(fn_, line, std::move(bytes_), std::move(callSiteLineNums_));
}
bool fail(ParseNode* pn, const char* str) {
return m_.fail(pn, str);
}
bool failf(ParseNode* pn, const char* fmt, ...) MOZ_FORMAT_PRINTF(3, 4) {
va_list ap;
@@ -4886,17 +4886,17 @@ CheckFunctionSignature(ModuleValidator&
{
if (sig.args().length() > MaxParams)
return m.failf(usepn, "too many parameters");
ModuleValidator::Func* existing = m.lookupFuncDef(name);
if (!existing) {
if (!CheckModuleLevelName(m, usepn, name))
return false;
- return m.addFuncDef(name, usepn->pn_pos.begin, Move(sig), func);
+ return m.addFuncDef(name, usepn->pn_pos.begin, std::move(sig), func);
}
const SigWithId& existingSig = m.env().sigs[existing->sigIndex()];
if (!CheckSignatureAgainstExisting(m, usepn, sig, existingSig))
return false;
*func = existing;
@@ -4919,20 +4919,20 @@ CheckInternalCall(FunctionValidator& f,
Type ret, Type* type)
{
MOZ_ASSERT(ret.isCanonical());
ValTypeVector args;
if (!CheckCallArgs<CheckIsArgType>(f, callNode, &args))
return false;
- Sig sig(Move(args), ret.canonicalToExprType());
+ Sig sig(std::move(args), ret.canonicalToExprType());
ModuleValidator::Func* callee;
- if (!CheckFunctionSignature(f.m(), callNode, Move(sig), calleeName, &callee))
+ if (!CheckFunctionSignature(f.m(), callNode, std::move(sig), calleeName, &callee))
return false;
if (!f.writeCall(callNode, MozOp::OldCallDirect))
return false;
if (!f.encoder().writeVarU32(callee->funcDefIndex()))
return false;
@@ -4957,17 +4957,17 @@ CheckFuncPtrTableAgainstExisting(ModuleV
*tableIndex = existing->tableIndex();
return true;
}
if (!CheckModuleLevelName(m, usepn, name))
return false;
- if (!m.declareFuncPtrTable(Move(sig), name, usepn->pn_pos.begin, mask, tableIndex))
+ if (!m.declareFuncPtrTable(std::move(sig), name, usepn->pn_pos.begin, mask, tableIndex))
return false;
return true;
}
static bool
CheckFuncPtrCall(FunctionValidator& f, ParseNode* callNode, Type ret, Type* type)
{
@@ -5002,20 +5002,20 @@ CheckFuncPtrCall(FunctionValidator& f, P
if (!indexType.isIntish())
return f.failf(indexNode, "%s is not a subtype of intish", indexType.toChars());
ValTypeVector args;
if (!CheckCallArgs<CheckIsArgType>(f, callNode, &args))
return false;
- Sig sig(Move(args), ret.canonicalToExprType());
+ Sig sig(std::move(args), ret.canonicalToExprType());
uint32_t tableIndex;
- if (!CheckFuncPtrTableAgainstExisting(f.m(), tableNode, name, Move(sig), mask, &tableIndex))
+ if (!CheckFuncPtrTableAgainstExisting(f.m(), tableNode, name, std::move(sig), mask, &tableIndex))
return false;
if (!f.writeCall(callNode, MozOp::OldCallIndirect))
return false;
// Call signature
if (!f.encoder().writeVarU32(f.m().table(tableIndex).sigIndex()))
return false;
@@ -5043,20 +5043,20 @@ CheckFFICall(FunctionValidator& f, Parse
return f.fail(callNode, "FFI calls can't return float");
if (ret.isSimd())
return f.fail(callNode, "FFI calls can't return SIMD values");
ValTypeVector args;
if (!CheckCallArgs<CheckIsExternType>(f, callNode, &args))
return false;
- Sig sig(Move(args), ret.canonicalToExprType());
+ Sig sig(std::move(args), ret.canonicalToExprType());
uint32_t importIndex;
- if (!f.m().declareImport(calleeName, Move(sig), ffiIndex, &importIndex))
+ if (!f.m().declareImport(calleeName, std::move(sig), ffiIndex, &importIndex))
return false;
if (!f.writeCall(callNode, Op::Call))
return false;
if (!f.encoder().writeVarU32(importIndex))
return false;
@@ -7301,17 +7301,17 @@ CheckFunction(ModuleValidator& m)
if (!CheckStatement(f, stmtIter))
return false;
}
if (!CheckFinalReturn(f, lastNonEmptyStmt))
return false;
ModuleValidator::Func* func = nullptr;
- if (!CheckFunctionSignature(m, fn, Sig(Move(args), f.returnedType()), FunctionName(fn), &func))
+ if (!CheckFunctionSignature(m, fn, Sig(std::move(args), f.returnedType()), FunctionName(fn), &func))
return false;
if (func->defined())
return m.failName(fn, "function '%s' already defined", FunctionName(fn));
f.define(func, line);
// Release the parser's lifo memory only after the last use of a parse node.
@@ -7389,20 +7389,20 @@ CheckFuncPtrTable(ModuleValidator& m, Pa
return false;
}
Sig copy;
if (!copy.clone(*sig))
return false;
uint32_t tableIndex;
- if (!CheckFuncPtrTableAgainstExisting(m, var, var->name(), Move(copy), mask, &tableIndex))
- return false;
-
- if (!m.defineFuncPtrTable(tableIndex, Move(elemFuncDefIndices)))
+ if (!CheckFuncPtrTableAgainstExisting(m, var, var->name(), std::move(copy), mask, &tableIndex))
+ return false;
+
+ if (!m.defineFuncPtrTable(tableIndex, std::move(elemFuncDefIndices)))
return m.fail(var, "duplicate function-pointer definition");
return true;
}
static bool
CheckFuncPtrTables(ModuleValidator& m)
{
@@ -8479,17 +8479,17 @@ class ModuleCharsForStore : ModuleChars
// and match the formals as a Vector of PropertyName.
isFunCtor_ = parser.pc->isStandaloneFunctionBody();
if (isFunCtor_) {
unsigned numArgs;
ParseNode* functionNode = parser.pc->functionBox()->functionNode;
ParseNode* arg = FunctionFormalParametersList(functionNode, &numArgs);
for (unsigned i = 0; i < numArgs; i++, arg = arg->pn_next) {
UniqueChars name = StringToNewUTF8CharsZ(nullptr, *arg->name());
- if (!name || !funCtorArgs_.append(Move(name)))
+ if (!name || !funCtorArgs_.append(std::move(name)))
return false;
}
}
return true;
}
size_t serializedSize() const {
@@ -8905,17 +8905,17 @@ js::CompileAsmJS(JSContext* cx, AsmJSPar
// asm.js module function. Special cases in the bytecode emitter avoid
// generating bytecode for asm.js functions, allowing this asm.js module
// function to be the finished result.
MOZ_ASSERT(funbox->function()->isInterpreted());
funbox->object = moduleFun;
// Success! Write to the console with a "warning" message.
*validated = true;
- SuccessfulValidation(parser, Move(message));
+ SuccessfulValidation(parser, std::move(message));
return NoExceptionPending(cx);
}
/*****************************************************************************/
// asm.js testing functions
bool
js::IsAsmJSModuleNative(Native native)
--- a/js/src/wasm/WasmAST.h
+++ b/js/src/wasm/WasmAST.h
@@ -133,22 +133,22 @@ class AstSig : public AstBase
ExprType ret_;
public:
explicit AstSig(LifoAlloc& lifo)
: args_(lifo),
ret_(ExprType::Void)
{}
AstSig(AstValTypeVector&& args, ExprType ret)
- : args_(Move(args)),
+ : args_(std::move(args)),
ret_(ret)
{}
AstSig(AstName name, AstSig&& rhs)
: name_(name),
- args_(Move(rhs.args_)),
+ args_(std::move(rhs.args_)),
ret_(rhs.ret_)
{}
const AstValTypeVector& args() const {
return args_;
}
ExprType ret() const {
return ret_;
}
@@ -396,17 +396,17 @@ class AstBlock : public AstExpr
AstExprVector exprs_;
public:
static const AstExprKind Kind = AstExprKind::Block;
explicit AstBlock(Op op, ExprType type, AstName name, AstExprVector&& exprs)
: AstExpr(Kind, type),
op_(op),
name_(name),
- exprs_(Move(exprs))
+ exprs_(std::move(exprs))
{}
Op op() const { return op_; }
AstName name() const { return name_; }
const AstExprVector& exprs() const { return exprs_; }
};
class AstBranch : public AstExpr
@@ -437,34 +437,34 @@ class AstCall : public AstExpr
{
Op op_;
AstRef func_;
AstExprVector args_;
public:
static const AstExprKind Kind = AstExprKind::Call;
AstCall(Op op, ExprType type, AstRef func, AstExprVector&& args)
- : AstExpr(Kind, type), op_(op), func_(func), args_(Move(args))
+ : AstExpr(Kind, type), op_(op), func_(func), args_(std::move(args))
{}
Op op() const { return op_; }
AstRef& func() { return func_; }
const AstExprVector& args() const { return args_; }
};
class AstCallIndirect : public AstExpr
{
AstRef sig_;
AstExprVector args_;
AstExpr* index_;
public:
static const AstExprKind Kind = AstExprKind::CallIndirect;
AstCallIndirect(AstRef sig, ExprType type, AstExprVector&& args, AstExpr* index)
- : AstExpr(Kind, type), sig_(sig), args_(Move(args)), index_(index)
+ : AstExpr(Kind, type), sig_(sig), args_(std::move(args)), index_(index)
{}
AstRef& sig() { return sig_; }
const AstExprVector& args() const { return args_; }
AstExpr* index() const { return index_; }
};
class AstReturn : public AstExpr
{
@@ -488,18 +488,18 @@ class AstIf : public AstExpr
public:
static const AstExprKind Kind = AstExprKind::If;
AstIf(ExprType type, AstExpr* cond, AstName name,
AstExprVector&& thenExprs, AstExprVector&& elseExprs)
: AstExpr(Kind, type),
cond_(cond),
name_(name),
- thenExprs_(Move(thenExprs)),
- elseExprs_(Move(elseExprs))
+ thenExprs_(std::move(thenExprs)),
+ elseExprs_(std::move(elseExprs))
{}
AstExpr& cond() const { return *cond_; }
const AstExprVector& thenExprs() const { return thenExprs_; }
bool hasElse() const { return elseExprs_.length(); }
const AstExprVector& elseExprs() const { MOZ_ASSERT(hasElse()); return elseExprs_; }
AstName name() const { return name_; }
};
@@ -754,17 +754,17 @@ class AstBranchTable : public AstExpr
public:
static const AstExprKind Kind = AstExprKind::BranchTable;
explicit AstBranchTable(AstExpr& index, AstRef def, AstRefVector&& table,
AstExpr* maybeValue)
: AstExpr(Kind, ExprType::Void),
index_(index),
default_(def),
- table_(Move(table)),
+ table_(std::move(table)),
value_(maybeValue)
{}
AstExpr& index() const { return index_; }
AstRef& def() { return default_; }
AstRefVector& table() { return table_; }
AstExpr* maybeValue() { return value_; }
};
@@ -777,19 +777,19 @@ class AstFunc : public AstNode
AstExprVector body_;
uint32_t endOffset_; // if applicable, offset in the binary format file
public:
AstFunc(AstName name, AstRef sig, AstValTypeVector&& vars,
AstNameVector&& locals, AstExprVector&& body)
: name_(name),
sig_(sig),
- vars_(Move(vars)),
- localNames_(Move(locals)),
- body_(Move(body)),
+ vars_(std::move(vars)),
+ localNames_(std::move(locals)),
+ body_(std::move(body)),
endOffset_(AstNodeUnknownOffset)
{}
AstRef& sig() { return sig_; }
const AstValTypeVector& vars() const { return vars_; }
const AstNameVector& locals() const { return localNames_; }
const AstExprVector& body() const { return body_; }
AstName name() const { return name_; }
uint32_t endOffset() const { return endOffset_; }
@@ -884,33 +884,33 @@ class AstExport : public AstNode
class AstDataSegment : public AstNode
{
AstExpr* offset_;
AstNameVector fragments_;
public:
AstDataSegment(AstExpr* offset, AstNameVector&& fragments)
- : offset_(offset), fragments_(Move(fragments))
+ : offset_(offset), fragments_(std::move(fragments))
{}
AstExpr* offset() const { return offset_; }
const AstNameVector& fragments() const { return fragments_; }
};
typedef AstVector<AstDataSegment*> AstDataSegmentVector;
class AstElemSegment : public AstNode
{
AstExpr* offset_;
AstRefVector elems_;
public:
AstElemSegment(AstExpr* offset, AstRefVector&& elems)
- : offset_(offset), elems_(Move(elems))
+ : offset_(offset), elems_(std::move(elems))
{}
AstExpr* offset() const { return offset_; }
AstRefVector& elems() { return elems_; }
const AstRefVector& elems() const { return elems_; }
};
typedef AstVector<AstElemSegment*> AstElemSegmentVector;
@@ -1034,17 +1034,17 @@ class AstModule : public AstNode
}
bool declare(AstSig&& sig, uint32_t* sigIndex) {
SigMap::AddPtr p = sigMap_.lookupForAdd(sig);
if (p) {
*sigIndex = p->value();
return true;
}
*sigIndex = sigs_.length();
- auto* lifoSig = new (lifo_) AstSig(AstName(), Move(sig));
+ auto* lifoSig = new (lifo_) AstSig(AstName(), std::move(sig));
return lifoSig &&
sigs_.append(lifoSig) &&
sigMap_.add(p, sigs_.back(), *sigIndex);
}
bool append(AstSig* sig) {
uint32_t sigIndex = sigs_.length();
if (!sigs_.append(sig))
return false;
@@ -1244,17 +1244,17 @@ class AstPop final : public AstExpr
class AstFirst : public AstExpr
{
AstExprVector exprs_;
public:
static const AstExprKind Kind = AstExprKind::First;
explicit AstFirst(AstExprVector&& exprs)
: AstExpr(Kind, ExprType::Limit),
- exprs_(Move(exprs))
+ exprs_(std::move(exprs))
{}
AstExprVector& exprs() { return exprs_; }
const AstExprVector& exprs() const { return exprs_; }
};
} // end wasm namespace
} // end js namespace
--- a/js/src/wasm/WasmBinaryToAST.cpp
+++ b/js/src/wasm/WasmBinaryToAST.cpp
@@ -158,17 +158,17 @@ class AstDecodeContext
}
AstExprVector exprs(lifo);
if (!exprs.append(prev))
return nullptr;
if (!exprs.append(voidNode))
return nullptr;
- return new(lifo) AstFirst(Move(exprs));
+ return new(lifo) AstFirst(std::move(exprs));
}
return voidNode;
}
void startFunction(AstDecodeOpIter* iter, const ValTypeVector* locals, ExprType retType)
{
iter_ = iter;
@@ -315,17 +315,17 @@ AstDecodeCall(AstDecodeContext& c)
return false;
const SigWithId* sig = c.env().funcSigs[funcIndex];
AstExprVector args(c.lifo);
if (!AstDecodeCallArgs(c, *sig, &args))
return false;
- AstCall* call = new(c.lifo) AstCall(Op::Call, sig->ret(), funcRef, Move(args));
+ AstCall* call = new(c.lifo) AstCall(Op::Call, sig->ret(), funcRef, std::move(args));
if (!call)
return false;
AstExpr* result = call;
if (IsVoid(sig->ret()))
result = c.handleVoidExpr(call);
if (!c.push(AstDecodeStackItem(result)))
@@ -351,17 +351,17 @@ AstDecodeCallIndirect(AstDecodeContext&
if (!GenerateRef(c, AstName(u"type"), sigIndex, &sigRef))
return false;
const SigWithId& sig = c.env().sigs[sigIndex];
AstExprVector args(c.lifo);
if (!AstDecodeCallArgs(c, sig, &args))
return false;
- AstCallIndirect* call = new(c.lifo) AstCallIndirect(sigRef, sig.ret(), Move(args), index.expr);
+ AstCallIndirect* call = new(c.lifo) AstCallIndirect(sigRef, sig.ret(), std::move(args), index.expr);
if (!call)
return false;
AstExpr* result = call;
if (IsVoid(sig.ret()))
result = c.handleVoidExpr(call);
if (!c.push(AstDecodeStackItem(result)))
@@ -416,17 +416,17 @@ AstDecodeBrTable(AstDecodeContext& c)
AstDecodeStackItem value;
if (!IsVoid(type))
value = c.popCopy();
AstRef def;
if (!AstDecodeGetBlockRef(c, defaultDepth, &def))
return false;
- auto branchTable = new(c.lifo) AstBranchTable(*index.expr, def, Move(table), value.expr);
+ auto branchTable = new(c.lifo) AstBranchTable(*index.expr, def, std::move(table), value.expr);
if (!branchTable)
return false;
if (!c.push(AstDecodeStackItem(branchTable)))
return false;
return true;
}
@@ -467,17 +467,17 @@ AstDecodeBlock(AstDecodeContext& c, Op o
for (auto i = c.exprs().begin() + c.depths().back(), e = c.exprs().end();
i != e; ++i) {
if (!exprs.append(i->expr))
return false;
}
c.exprs().shrinkTo(c.depths().popCopy());
AstName name = c.blockLabels().popCopy();
- AstBlock* block = new(c.lifo) AstBlock(op, type, name, Move(exprs));
+ AstBlock* block = new(c.lifo) AstBlock(op, type, name, std::move(exprs));
if (!block)
return false;
AstExpr* result = block;
if (IsVoid(type))
result = c.handleVoidExpr(block);
if (!c.push(AstDecodeStackItem(result)))
@@ -544,17 +544,17 @@ AstDecodeIf(AstDecodeContext& c)
}
c.exprs().shrinkTo(c.depths().back());
}
c.depths().popBack();
AstName name = c.blockLabels().popCopy();
- AstIf* if_ = new(c.lifo) AstIf(type, cond.expr, name, Move(thenExprs), Move(elseExprs));
+ AstIf* if_ = new(c.lifo) AstIf(type, cond.expr, name, std::move(thenExprs), std::move(elseExprs));
if (!if_)
return false;
AstExpr* result = if_;
if (IsVoid(type))
result = c.handleVoidExpr(if_);
if (!c.push(AstDecodeStackItem(result)))
@@ -1942,17 +1942,17 @@ AstDecodeFunctionBody(AstDecodeContext &
return c.d.fail("function body length mismatch");
size_t sigIndex = c.env().funcIndexToSigIndex(funcIndex);
AstRef sigRef;
if (!GenerateRef(c, AstName(u"type"), sigIndex, &sigRef))
return false;
- *func = new(c.lifo) AstFunc(funcName, sigRef, Move(vars), Move(localsNames), Move(body));
+ *func = new(c.lifo) AstFunc(funcName, sigRef, std::move(vars), std::move(localsNames), std::move(body));
if (!*func)
return false;
(*func)->setOffset(offset);
(*func)->setEndOffset(endOffset);
return true;
}
@@ -1966,23 +1966,23 @@ AstCreateSignatures(AstDecodeContext& c)
for (size_t sigIndex = 0; sigIndex < sigs.length(); sigIndex++) {
const Sig& sig = sigs[sigIndex];
AstValTypeVector args(c.lifo);
if (!args.appendAll(sig.args()))
return false;
- AstSig sigNoName(Move(args), sig.ret());
+ AstSig sigNoName(std::move(args), sig.ret());
AstName sigName;
if (!GenerateName(c, AstName(u"type"), sigIndex, &sigName))
return false;
- AstSig* astSig = new(c.lifo) AstSig(sigName, Move(sigNoName));
+ AstSig* astSig = new(c.lifo) AstSig(sigName, std::move(sigNoName));
if (!astSig || !c.module().append(astSig))
return false;
}
return true;
}
static bool
@@ -2213,17 +2213,17 @@ AstCreateElems(AstDecodeContext &c)
for (uint32_t i : seg.elemFuncIndices)
elems.infallibleAppend(AstRef(i));
AstExpr* offset = ToAstExpr(c, seg.offset);
if (!offset)
return false;
- AstElemSegment* segment = new(c.lifo) AstElemSegment(offset, Move(elems));
+ AstElemSegment* segment = new(c.lifo) AstElemSegment(offset, std::move(elems));
if (!segment || !c.module().append(segment))
return false;
}
return true;
}
static bool
@@ -2312,17 +2312,17 @@ AstDecodeModuleTail(AstDecodeContext& c)
AstNameVector fragments(c.lifo);
for (size_t start = 0; start < s.length; start += WRAP_DATA_BYTES) {
AstName name(buffer + start, Min(WRAP_DATA_BYTES, s.length - start));
if (!fragments.append(name))
return false;
}
- AstDataSegment* segment = new(c.lifo) AstDataSegment(offset, Move(fragments));
+ AstDataSegment* segment = new(c.lifo) AstDataSegment(offset, std::move(fragments));
if (!segment || !c.module().append(segment))
return false;
}
return true;
}
bool
--- a/js/src/wasm/WasmCode.cpp
+++ b/js/src/wasm/WasmCode.cpp
@@ -271,17 +271,17 @@ SendCodeRangesToProfiler(const ModuleSeg
#endif
}
}
ModuleSegment::ModuleSegment(Tier tier,
UniqueCodeBytes codeBytes,
uint32_t codeLength,
const LinkDataTier& linkData)
- : CodeSegment(Move(codeBytes), codeLength, CodeSegment::Kind::Module),
+ : CodeSegment(std::move(codeBytes), codeLength, CodeSegment::Kind::Module),
tier_(tier),
outOfBoundsCode_(base() + linkData.outOfBoundsOffset),
unalignedAccessCode_(base() + linkData.unalignedAccessOffset),
trapCode_(base() + linkData.trapOffset)
{
}
/* static */ UniqueModuleSegment
@@ -291,31 +291,31 @@ ModuleSegment::create(Tier tier, MacroAs
UniqueCodeBytes codeBytes = AllocateCodeBytes(codeLength);
if (!codeBytes)
return nullptr;
// We'll flush the icache after static linking, in initialize().
masm.executableCopy(codeBytes.get(), /* flushICache = */ false);
- return js::MakeUnique<ModuleSegment>(tier, Move(codeBytes), codeLength, linkData);
+ return js::MakeUnique<ModuleSegment>(tier, std::move(codeBytes), codeLength, linkData);
}
/* static */ UniqueModuleSegment
ModuleSegment::create(Tier tier, const Bytes& unlinkedBytes, const LinkDataTier& linkData)
{
uint32_t codeLength = unlinkedBytes.length();
UniqueCodeBytes codeBytes = AllocateCodeBytes(codeLength);
if (!codeBytes)
return nullptr;
memcpy(codeBytes.get(), unlinkedBytes.begin(), codeLength);
- return js::MakeUnique<ModuleSegment>(tier, Move(codeBytes), codeLength, linkData);
+ return js::MakeUnique<ModuleSegment>(tier, std::move(codeBytes), codeLength, linkData);
}
bool
ModuleSegment::initialize(const CodeTier& codeTier,
const ShareableBytes& bytecode,
const LinkDataTier& linkData,
const Metadata& metadata,
const MetadataTier& metadataTier)
@@ -372,17 +372,17 @@ ModuleSegment::deserialize(const uint8_t
UniqueCodeBytes bytes = AllocateCodeBytes(length);
if (!bytes)
return nullptr;
cursor = ReadBytes(cursor, bytes.get(), length);
if (!cursor)
return nullptr;
- *segment = js::MakeUnique<ModuleSegment>(Tier::Serialized, Move(bytes), length, linkData);
+ *segment = js::MakeUnique<ModuleSegment>(Tier::Serialized, std::move(bytes), length, linkData);
if (!*segment)
return nullptr;
return cursor;
}
const CodeRange*
ModuleSegment::lookupRange(const void* pc) const
@@ -541,17 +541,17 @@ MetadataTier::deserialize(const uint8_t*
UniqueLazyStubSegment
LazyStubSegment::create(const CodeTier& codeTier, size_t length)
{
UniqueCodeBytes codeBytes = AllocateCodeBytes(length);
if (!codeBytes)
return nullptr;
- auto segment = js::MakeUnique<LazyStubSegment>(Move(codeBytes), length);
+ auto segment = js::MakeUnique<LazyStubSegment>(std::move(codeBytes), length);
if (!segment || !segment->initialize(codeTier))
return nullptr;
return segment;
}
bool
LazyStubSegment::hasSpace(size_t bytes) const
@@ -677,17 +677,17 @@ LazyStubTier::createMany(HasGcTypes gcTy
size_t codeLength = LazyStubSegment::AlignBytesNeeded(masm.bytesNeeded());
if (!stubSegments_.length() || !stubSegments_[lastStubSegmentIndex_]->hasSpace(codeLength)) {
size_t newSegmentSize = Max(codeLength, ExecutableCodePageSize);
UniqueLazyStubSegment newSegment = LazyStubSegment::create(codeTier, newSegmentSize);
if (!newSegment)
return false;
lastStubSegmentIndex_ = stubSegments_.length();
- if (!stubSegments_.emplaceBack(Move(newSegment)))
+ if (!stubSegments_.emplaceBack(std::move(newSegment)))
return false;
}
LazyStubSegment* segment = stubSegments_[lastStubSegmentIndex_].get();
*stubSegmentIndex = lastStubSegmentIndex_;
size_t interpRangeIndex;
uint8_t* codePtr = nullptr;
@@ -713,17 +713,17 @@ LazyStubTier::createMany(HasGcTypes gcTy
MOZ_ASSERT(cr.value.isInterpEntry());
MOZ_ASSERT(cr.value.funcIndex() == fe.funcIndex());
LazyFuncExport lazyExport(fe.funcIndex(), *stubSegmentIndex, interpRangeIndex);
size_t exportIndex;
MOZ_ALWAYS_FALSE(BinarySearch(ProjectLazyFuncIndex(exports_), 0, exports_.length(),
fe.funcIndex(), &exportIndex));
- MOZ_ALWAYS_TRUE(exports_.insert(exports_.begin() + exportIndex, Move(lazyExport)));
+ MOZ_ALWAYS_TRUE(exports_.insert(exports_.begin() + exportIndex, std::move(lazyExport)));
// Functions with anyref in their sig have only one entry (interp).
// All other functions get an extra jit entry.
interpRangeIndex += fe.sig().temporarilyUnsupportedAnyRef() ? 1 : 2;
}
return true;
}
@@ -1001,17 +1001,17 @@ CodeTier::deserialize(const uint8_t* cur
if (!cursor)
return nullptr;
UniqueModuleSegment segment;
cursor = ModuleSegment::deserialize(cursor, linkData, &segment);
if (!cursor)
return nullptr;
- *codeTier = js::MakeUnique<CodeTier>(Move(metadata), Move(segment));
+ *codeTier = js::MakeUnique<CodeTier>(std::move(metadata), std::move(segment));
if (!*codeTier)
return nullptr;
return cursor;
}
void
CodeTier::addSizeOfMisc(MallocSizeOf mallocSizeOf, size_t* code, size_t* data) const
@@ -1074,20 +1074,20 @@ JumpTables::init(CompileMode mode, const
setTieringEntry(cr.funcIndex(), codeBase + cr.funcTierEntry());
else if (cr.isJitEntry())
setJitEntry(cr.funcIndex(), codeBase + cr.begin());
}
return true;
}
Code::Code(UniqueCodeTier tier1, const Metadata& metadata, JumpTables&& maybeJumpTables)
- : tier1_(Move(tier1)),
+ : tier1_(std::move(tier1)),
metadata_(&metadata),
profilingLabels_(mutexid::WasmCodeProfilingLabels, CacheableCharsVector()),
- jumpTables_(Move(maybeJumpTables))
+ jumpTables_(std::move(maybeJumpTables))
{}
bool
Code::initialize(const ShareableBytes& bytecode, const LinkDataTier& linkData)
{
MOZ_ASSERT(!initialized());
if (!tier1_->initialize(*this, bytecode, linkData, *metadata_))
@@ -1102,17 +1102,17 @@ Code::setTier2(UniqueCodeTier tier2, con
const LinkDataTier& linkData) const
{
MOZ_RELEASE_ASSERT(!hasTier2());
MOZ_RELEASE_ASSERT(tier2->tier() == Tier::Ion && tier1_->tier() == Tier::Baseline);
if (!tier2->initialize(*this, bytecode, linkData, *metadata_))
return false;
- tier2_ = Move(tier2);
+ tier2_ = std::move(tier2);
return true;
}
void
Code::commitTier2() const
{
MOZ_RELEASE_ASSERT(!hasTier2());
@@ -1319,17 +1319,17 @@ Code::ensureProfilingLabels(const Bytes*
if (!label)
return;
if (codeRange.funcIndex() >= labels->length()) {
if (!labels->resize(codeRange.funcIndex() + 1))
return;
}
- ((CacheableCharsVector&)labels)[codeRange.funcIndex()] = Move(label);
+ ((CacheableCharsVector&)labels)[codeRange.funcIndex()] = std::move(label);
}
}
const char*
Code::profilingLabel(uint32_t funcIndex) const
{
auto labels = profilingLabels_.lock();
@@ -1411,15 +1411,15 @@ Code::deserialize(const uint8_t* cursor,
cursor = CodeTier::deserialize(cursor, linkData.tier(Tier::Serialized), &codeTier);
if (!cursor)
return nullptr;
JumpTables jumpTables;
if (!jumpTables.init(CompileMode::Once, codeTier->segment(), codeTier->metadata().codeRanges))
return nullptr;
- MutableCode code = js_new<Code>(Move(codeTier), metadata, Move(jumpTables));
+ MutableCode code = js_new<Code>(std::move(codeTier), metadata, std::move(jumpTables));
if (!code || !code->initialize(bytecode, linkData.tier(Tier::Serialized)))
return nullptr;
*out = code;
return cursor;
}
--- a/js/src/wasm/WasmCode.h
+++ b/js/src/wasm/WasmCode.h
@@ -38,17 +38,17 @@ class LinkData;
// ShareableBytes is a reference-counted Vector of bytes.
struct ShareableBytes : ShareableBase<ShareableBytes>
{
// Vector is 'final', so instead make Vector a member and add boilerplate.
Bytes bytes;
ShareableBytes() = default;
- explicit ShareableBytes(Bytes&& bytes) : bytes(Move(bytes)) {}
+ explicit ShareableBytes(Bytes&& bytes) : bytes(std::move(bytes)) {}
size_t sizeOfExcludingThis(MallocSizeOf m) const { return bytes.sizeOfExcludingThis(m); }
const uint8_t* begin() const { return bytes.begin(); }
const uint8_t* end() const { return bytes.end(); }
size_t length() const { return bytes.length(); }
bool append(const uint8_t *p, uint32_t ct) { return bytes.append(p, ct); }
};
typedef RefPtr<ShareableBytes> MutableBytes;
@@ -83,17 +83,17 @@ class CodeSegment
static UniqueCodeBytes AllocateCodeBytes(uint32_t codeLength);
enum class Kind {
LazyStubs,
Module
};
CodeSegment(UniqueCodeBytes bytes, uint32_t length, Kind kind)
- : bytes_(Move(bytes)),
+ : bytes_(std::move(bytes)),
length_(length),
kind_(kind),
codeTier_(nullptr),
unregisterOnDestroy_(false)
{}
bool initialize(const CodeTier& codeTier);
@@ -197,17 +197,17 @@ class FuncExport
uint32_t interpCodeRangeIndex_;
uint32_t eagerInterpEntryOffset_; // Machine code offset
bool hasEagerStubs_;
} pod;
public:
FuncExport() = default;
explicit FuncExport(Sig&& sig, uint32_t funcIndex, bool hasEagerStubs)
- : sig_(Move(sig))
+ : sig_(std::move(sig))
{
pod.funcIndex_ = funcIndex;
pod.interpCodeRangeIndex_ = UINT32_MAX;
pod.eagerInterpEntryOffset_ = UINT32_MAX;
pod.hasEagerStubs_ = hasEagerStubs;
}
void initEagerInterpEntryOffset(uint32_t entryOffset) {
MOZ_ASSERT(pod.eagerInterpEntryOffset_ == UINT32_MAX);
@@ -264,17 +264,17 @@ class FuncImport
} pod;
public:
FuncImport() {
memset(&pod, 0, sizeof(CacheablePod));
}
FuncImport(Sig&& sig, uint32_t tlsDataOffset)
- : sig_(Move(sig))
+ : sig_(std::move(sig))
{
pod.tlsDataOffset_ = tlsDataOffset;
pod.interpExitCodeOffset_ = 0;
pod.jitExitCodeOffset_ = 0;
}
void initInterpExitOffset(uint32_t off) {
MOZ_ASSERT(!pod.interpExitCodeOffset_);
@@ -504,17 +504,17 @@ using LazyStubSegmentVector = Vector<Uni
class LazyStubSegment : public CodeSegment
{
CodeRangeVector codeRanges_;
size_t usedBytes_;
public:
LazyStubSegment(UniqueCodeBytes bytes, size_t length)
- : CodeSegment(Move(bytes), length, CodeSegment::Kind::LazyStubs),
+ : CodeSegment(std::move(bytes), length, CodeSegment::Kind::LazyStubs),
usedBytes_(0)
{}
static UniqueLazyStubSegment create(const CodeTier& codeTier, size_t codeLength);
static size_t AlignBytesNeeded(size_t bytes) { return AlignBytes(bytes, gc::SystemPageSize()); }
bool hasSpace(size_t bytes) const;
@@ -609,18 +609,18 @@ class CodeTier
return mutexid::WasmLazyStubsTier1;
MOZ_ASSERT(tier == Tier::Ion);
return mutexid::WasmLazyStubsTier2;
}
public:
CodeTier(UniqueMetadataTier metadata, UniqueModuleSegment segment)
: code_(nullptr),
- metadata_(Move(metadata)),
- segment_(Move(segment)),
+ metadata_(std::move(metadata)),
+ segment_(std::move(segment)),
lazyStubs_(mutexForTier(segment_->tier()))
{}
bool initialized() const { return !!code_ && segment_->initialized(); }
bool initialize(const Code& code,
const ShareableBytes& bytecode,
const LinkDataTier& linkData,
--- a/js/src/wasm/WasmCompile.cpp
+++ b/js/src/wasm/WasmCompile.cpp
@@ -100,17 +100,17 @@ CompileArgs::initFromContext(JSContext*
testTiering = (cx->options().testWasmAwaitTier2() || JitOptions.wasmDelayTier2) && !gcEnabled;
// Debug information such as source view or debug traps will require
// additional memory and permanently stay in baseline code, so we try to
// only enable it when a developer actually cares: when the debugger tab
// is open.
debugEnabled = cx->realm()->debuggerObservesAsmJS();
- this->scriptedCaller = Move(scriptedCaller);
+ this->scriptedCaller = std::move(scriptedCaller);
return assumptions.initBuildIdFromContext(cx);
}
// Classify the current system as one of a set of recognizable classes. This
// really needs to get our tier-1 systems right.
//
// TODO: We don't yet have a good measure of how fast a system is. We
// distinguish between mobile and desktop because these are very different kinds
--- a/js/src/wasm/WasmCompile.h
+++ b/js/src/wasm/WasmCompile.h
@@ -45,18 +45,18 @@ struct CompileArgs : ShareableBase<Compi
bool baselineEnabled;
bool debugEnabled;
bool ionEnabled;
bool sharedMemoryEnabled;
HasGcTypes gcTypesEnabled;
bool testTiering;
CompileArgs(Assumptions&& assumptions, ScriptedCaller&& scriptedCaller)
- : assumptions(Move(assumptions)),
- scriptedCaller(Move(scriptedCaller)),
+ : assumptions(std::move(assumptions)),
+ scriptedCaller(std::move(scriptedCaller)),
baselineEnabled(false),
debugEnabled(false),
ionEnabled(false),
sharedMemoryEnabled(false),
gcTypesEnabled(HasGcTypes::False),
testTiering(false)
{}
--- a/js/src/wasm/WasmDebug.cpp
+++ b/js/src/wasm/WasmDebug.cpp
@@ -46,17 +46,17 @@ GeneratedSourceMap::searchLineByOffset(J
// Lazily build sorted array for fast log(n) lookup.
if (!sortedByOffsetExprLocIndices_) {
ExprLocIndexVector scratch;
auto indices = MakeUnique<ExprLocIndexVector>();
if (!indices || !indices->resize(exprlocsLength) || !scratch.resize(exprlocsLength)) {
ReportOutOfMemory(cx);
return false;
}
- sortedByOffsetExprLocIndices_ = Move(indices);
+ sortedByOffsetExprLocIndices_ = std::move(indices);
for (size_t i = 0; i < exprlocsLength; i++)
(*sortedByOffsetExprLocIndices_)[i] = i;
auto compareExprLocViaIndex = [&](uint32_t i, uint32_t j, bool* lessOrEqualp) -> bool {
*lessOrEqualp = exprlocs_[i].offset <= exprlocs_[j].offset;
return true;
};
@@ -85,17 +85,17 @@ GeneratedSourceMap::sizeOfExcludingThis(
if (sortedByOffsetExprLocIndices_)
size += sortedByOffsetExprLocIndices_->sizeOfIncludingThis(mallocSizeOf);
return size;
}
DebugState::DebugState(SharedCode code,
const ShareableBytes* maybeBytecode,
bool binarySource)
- : code_(Move(code)),
+ : code_(std::move(code)),
maybeBytecode_(maybeBytecode),
binarySource_(binarySource),
enterAndLeaveFrameTrapsCounter_(0)
{
MOZ_ASSERT_IF(debugEnabled(), maybeBytecode);
}
const char enabledMessage[] =
@@ -142,17 +142,17 @@ DebugState::createText(JSContext* cx)
MOZ_ASSERT(!maybeSourceMap_);
} else {
const Bytes& bytes = maybeBytecode_->bytes;
auto sourceMap = MakeUnique<GeneratedSourceMap>();
if (!sourceMap) {
ReportOutOfMemory(cx);
return nullptr;
}
- maybeSourceMap_ = Move(sourceMap);
+ maybeSourceMap_ = std::move(sourceMap);
if (!BinaryToText(cx, bytes.begin(), bytes.length(), buffer, maybeSourceMap_.get()))
return nullptr;
#if DEBUG
// Check that expression locations are sorted by line number.
uint32_t lastLineno = 0;
for (const ExprLoc& loc : maybeSourceMap_->exprlocs()) {
--- a/js/src/wasm/WasmGenerator.cpp
+++ b/js/src/wasm/WasmGenerator.cpp
@@ -124,17 +124,17 @@ ModuleGenerator::~ModuleGenerator()
}
}
} else {
MOZ_ASSERT(!outstanding_);
}
// Propagate error state.
if (error_ && !*error_)
- *error_ = Move(taskState_.lock()->errorMessage);
+ *error_ = std::move(taskState_.lock()->errorMessage);
}
bool
ModuleGenerator::allocateGlobalBytes(uint32_t bytes, uint32_t align, uint32_t* globalDataOffset)
{
CheckedInt<uint32_t> newGlobalDataLength(metadata_->globalDataLength);
newGlobalDataLength += ComputeByteAlignment(newGlobalDataLength.value(), align);
@@ -228,17 +228,17 @@ ModuleGenerator::init(Metadata* maybeAsm
if (!allocateGlobalBytes(sizeof(FuncImportTls), sizeof(void*), &globalDataOffset))
return false;
env_->funcImportGlobalDataOffsets[i] = globalDataOffset;
Sig copy;
if (!copy.clone(*env_->funcSigs[i]))
return false;
- if (!metadataTier_->funcImports.emplaceBack(Move(copy), globalDataOffset))
+ if (!metadataTier_->funcImports.emplaceBack(std::move(copy), globalDataOffset))
return false;
}
for (TableDesc& table : env_->tables) {
if (!allocateGlobalBytes(sizeof(TableTls), sizeof(void*), &table.globalDataOffset))
return false;
}
@@ -250,17 +250,17 @@ ModuleGenerator::init(Metadata* maybeAsm
return false;
sig.id = SigIdDesc::global(sig, globalDataOffset);
Sig copy;
if (!copy.clone(sig))
return false;
- if (!metadata_->sigIds.emplaceBack(Move(copy), sig.id))
+ if (!metadata_->sigIds.emplaceBack(std::move(copy), sig.id))
return false;
} else {
sig.id = SigIdDesc::immediate(sig);
}
}
}
for (GlobalDesc& global : env_->globals) {
@@ -321,17 +321,17 @@ ModuleGenerator::init(Metadata* maybeAsm
if (!metadataTier_->funcExports.reserve(exportedFuncs.length()))
return false;
for (const ExportedFunc& funcIndex : exportedFuncs) {
Sig sig;
if (!sig.clone(*env_->funcSigs[funcIndex.index()]))
return false;
- metadataTier_->funcExports.infallibleEmplaceBack(Move(sig), funcIndex.index(),
+ metadataTier_->funcExports.infallibleEmplaceBack(std::move(sig), funcIndex.index(),
funcIndex.isExplicit());
}
// Determine whether parallel or sequential compilation is to be used and
// initialize the CompileTasks that will be used in either mode.
GlobalHelperThreadState& threads = HelperThreadState();
MOZ_ASSERT(threads.threadCount > 1);
@@ -642,17 +642,17 @@ wasm::ExecuteCompileTaskFromHelperThread
UniqueChars error;
bool ok = ExecuteCompileTask(task, &error);
auto taskState = task->state.lock();
if (!ok || !taskState->finished.append(task)) {
taskState->numFailed++;
if (!taskState->errorMessage)
- taskState->errorMessage = Move(error);
+ taskState->errorMessage = std::move(error);
}
taskState.notify_one(/* failed or finished */);
}
bool
ModuleGenerator::finishTask(CompileTask* task)
{
@@ -742,17 +742,17 @@ ModuleGenerator::compileFuncDef(uint32_t
if (freeTasks_.empty() && !finishOutstandingTask())
return false;
currentTask_ = freeTasks_.popCopy();
}
uint32_t funcBytecodeLength = end - begin;
FuncCompileInputVector& inputs = currentTask_->inputs;
- if (!inputs.emplaceBack(funcIndex, lineOrBytecode, begin, end, Move(lineNums)))
+ if (!inputs.emplaceBack(funcIndex, lineOrBytecode, begin, end, std::move(lineNums)))
return false;
uint32_t threshold;
switch (tier()) {
case Tier::Baseline: threshold = JitOptions.wasmBatchBaselineThreshold; break;
case Tier::Ion: threshold = JitOptions.wasmBatchIonThreshold; break;
default: MOZ_CRASH("Invalid tier value"); break;
}
@@ -838,20 +838,20 @@ ModuleGenerator::finishMetadata(const Sh
// Copy over data from the ModuleEnvironment.
metadata_->memoryUsage = env_->memoryUsage;
metadata_->temporaryHasGcTypes = env_->gcTypesEnabled;
metadata_->minMemoryLength = env_->minMemoryLength;
metadata_->maxMemoryLength = env_->maxMemoryLength;
metadata_->startFuncIndex = env_->startFuncIndex;
metadata_->moduleName = env_->moduleName;
- metadata_->tables = Move(env_->tables);
- metadata_->globals = Move(env_->globals);
- metadata_->funcNames = Move(env_->funcNames);
- metadata_->customSections = Move(env_->customSections);
+ metadata_->tables = std::move(env_->tables);
+ metadata_->globals = std::move(env_->globals);
+ metadata_->funcNames = std::move(env_->funcNames);
+ metadata_->customSections = std::move(env_->customSections);
// Inflate the global bytes up to page size so that the total bytes are a
// page size (as required by the allocator functions).
metadata_->globalDataLength = AlignBytes(metadata_->globalDataLength, gc::SystemPageSize());
// These Vectors can get large and the excess capacity can be significant,
// so realloc them down to size.
@@ -889,17 +889,17 @@ ModuleGenerator::finishMetadata(const Sh
return false;
if (!metadata_->debugFuncReturnTypes.resize(numSigs))
return false;
for (size_t i = 0; i < numSigs; i++) {
if (!metadata_->debugFuncArgTypes[i].appendAll(env_->funcSigs[i]->args()))
return false;
metadata_->debugFuncReturnTypes[i] = env_->funcSigs[i]->ret();
}
- metadataTier_->debugFuncToCodeRange = Move(funcToCodeRange_);
+ metadataTier_->debugFuncToCodeRange = std::move(funcToCodeRange_);
static_assert(sizeof(ModuleHash) <= sizeof(mozilla::SHA1Sum::Hash),
"The ModuleHash size shall not exceed the SHA1 hash size.");
mozilla::SHA1Sum::Hash hash;
mozilla::SHA1Sum sha1Sum;
sha1Sum.update(bytecode.begin(), bytecode.length());
sha1Sum.finish(hash);
memcpy(metadata_->debugHash, hash, sizeof(ModuleHash));
@@ -961,37 +961,37 @@ ModuleGenerator::finishModule(const Shar
UniqueConstBytes maybeDebuggingBytes;
if (env_->debugEnabled()) {
MOZ_ASSERT(mode() == CompileMode::Once);
Bytes bytes;
if (!bytes.resize(masm_.bytesNeeded()))
return nullptr;
masm_.executableCopy(bytes.begin(), /* flushICache = */ false);
- maybeDebuggingBytes = js::MakeUnique<Bytes>(Move(bytes));
+ maybeDebuggingBytes = js::MakeUnique<Bytes>(std::move(bytes));
if (!maybeDebuggingBytes)
return nullptr;
}
- auto codeTier = js::MakeUnique<CodeTier>(Move(metadataTier_), Move(moduleSegment));
+ auto codeTier = js::MakeUnique<CodeTier>(std::move(metadataTier_), std::move(moduleSegment));
if (!codeTier)
return nullptr;
- MutableCode code = js_new<Code>(Move(codeTier), *metadata_, Move(jumpTables));
+ MutableCode code = js_new<Code>(std::move(codeTier), *metadata_, std::move(jumpTables));
if (!code || !code->initialize(bytecode, *linkDataTier_))
return nullptr;
- SharedModule module(js_new<Module>(Move(assumptions_),
+ SharedModule module(js_new<Module>(std::move(assumptions_),
*code,
- Move(maybeDebuggingBytes),
- LinkData(Move(linkDataTier_)),
- Move(env_->imports),
- Move(env_->exports),
- Move(env_->dataSegments),
- Move(env_->elemSegments),
+ std::move(maybeDebuggingBytes),
+ LinkData(std::move(linkDataTier_)),
+ std::move(env_->imports),
+ std::move(env_->exports),
+ std::move(env_->dataSegments),
+ std::move(env_->elemSegments),
bytecode));
if (!module)
return nullptr;
if (mode() == CompileMode::Tier1)
module->startTier2(*compileArgs_);
return module;
@@ -1006,27 +1006,27 @@ ModuleGenerator::finishTier2(Module& mod
if (cancelled_ && *cancelled_)
return false;
UniqueModuleSegment moduleSegment = finish(module.bytecode());
if (!moduleSegment)
return false;
- auto tier2 = js::MakeUnique<CodeTier>(Move(metadataTier_), Move(moduleSegment));
+ auto tier2 = js::MakeUnique<CodeTier>(std::move(metadataTier_), std::move(moduleSegment));
if (!tier2)
return false;
if (MOZ_UNLIKELY(JitOptions.wasmDelayTier2)) {
// Introduce an artificial delay when testing wasmDelayTier2, since we
// want to exercise both tier1 and tier2 code in this case.
std::this_thread::sleep_for(std::chrono::milliseconds(500));
}
- return module.finishTier2(Move(linkDataTier_), Move(tier2), env_);
+ return module.finishTier2(std::move(linkDataTier_), std::move(tier2), env_);
}
size_t
CompiledCode::sizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const
{
size_t trapSitesSize = 0;
for (const TrapSiteVector& vec : trapSites)
trapSitesSize += vec.sizeOfExcludingThis(mallocSizeOf);
--- a/js/src/wasm/WasmGenerator.h
+++ b/js/src/wasm/WasmGenerator.h
@@ -46,17 +46,17 @@ struct FuncCompileInput
uint32_t lineOrBytecode,
const uint8_t* begin,
const uint8_t* end,
Uint32Vector&& callSiteLineNums)
: begin(begin),
end(end),
index(index),
lineOrBytecode(lineOrBytecode),
- callSiteLineNums(Move(callSiteLineNums))
+ callSiteLineNums(std::move(callSiteLineNums))
{}
};
typedef Vector<FuncCompileInput, 8, SystemAllocPolicy> FuncCompileInputVector;
// CompiledCode contains the resulting code and metadata for a set of compiled
// input functions or stubs.
--- a/js/src/wasm/WasmInstance.cpp
+++ b/js/src/wasm/WasmInstance.cpp
@@ -482,20 +482,20 @@ Instance::Instance(JSContext* cx,
HandleWasmMemoryObject memory,
SharedTableVector&& tables,
Handle<FunctionVector> funcImports,
const ValVector& globalImportValues,
const WasmGlobalObjectVector& globalObjs)
: realm_(cx->realm()),
object_(object),
code_(code),
- debug_(Move(debug)),
- tlsData_(Move(tlsDataIn)),
+ debug_(std::move(debug)),
+ tlsData_(std::move(tlsDataIn)),
memory_(memory),
- tables_(Move(tables)),
+ tables_(std::move(tables)),
enterFrameTrapsEnabled_(false)
{
#ifdef DEBUG
for (auto t : code_->tiers())
MOZ_ASSERT(funcImports.length() == metadata(t).funcImports.length());
#endif
MOZ_ASSERT(tables_.length() == metadata().tables.length());
--- a/js/src/wasm/WasmJS.cpp
+++ b/js/src/wasm/WasmJS.cpp
@@ -333,17 +333,17 @@ wasm::Eval(JSContext* cx, Handle<TypedAr
return false;
}
ScriptedCaller scriptedCaller;
if (!DescribeScriptedCaller(cx, &scriptedCaller, "wasm_eval"))
return false;
MutableCompileArgs compileArgs = cx->new_<CompileArgs>();
- if (!compileArgs || !compileArgs->initFromContext(cx, Move(scriptedCaller)))
+ if (!compileArgs || !compileArgs->initFromContext(cx, std::move(scriptedCaller)))
return false;
UniqueChars error;
UniqueCharsVector warnings;
SharedModule module = CompileBuffer(*compileArgs, *bytecode, &error, &warnings);
if (!module) {
if (error) {
JS_ReportErrorNumberUTF8(cx, GetErrorMessage, nullptr, JSMSG_WASM_COMPILE_ERROR,
@@ -866,17 +866,17 @@ InitCompileArgs(JSContext* cx, const cha
ScriptedCaller scriptedCaller;
if (!DescribeScriptedCaller(cx, &scriptedCaller, introducer))
return nullptr;
MutableCompileArgs compileArgs = cx->new_<CompileArgs>();
if (!compileArgs)
return nullptr;
- if (!compileArgs->initFromContext(cx, Move(scriptedCaller)))
+ if (!compileArgs->initFromContext(cx, std::move(scriptedCaller)))
return nullptr;
return compileArgs;
}
static bool
ReportCompileWarnings(JSContext* cx, const UniqueCharsVector& warnings)
{
@@ -1103,20 +1103,20 @@ WasmInstanceObject::create(JSContext* cx
// The INSTANCE_SLOT may not be initialized if Instance allocation fails,
// leading to an observable "newborn" state in tracing/finalization.
MOZ_ASSERT(obj->isNewborn());
// Root the Instance via WasmInstanceObject before any possible GC.
auto* instance = cx->new_<Instance>(cx,
obj,
code,
- Move(debug),
- Move(tlsData),
+ std::move(debug),
+ std::move(tlsData),
memory,
- Move(tables),
+ std::move(tables),
funcImports,
globalImportValues,
globalObjs);
if (!instance)
return nullptr;
obj->initReservedSlot(INSTANCE_SLOT, PrivateValue(instance));
MOZ_ASSERT(!obj->isNewborn());
@@ -2387,17 +2387,17 @@ Reject(JSContext* cx, const CompileArgs&
// Ideally we'd report a JSMSG_WASM_COMPILE_ERROR here, but there's no easy
// way to create an ErrorObject for an arbitrary error code with multiple
// replacements.
UniqueChars str(JS_smprintf("wasm validation error: %s", error.get()));
if (!str)
return false;
- RootedString message(cx, NewLatin1StringZ(cx, Move(str)));
+ RootedString message(cx, NewLatin1StringZ(cx, std::move(str)));
if (!message)
return false;
RootedObject errorObj(cx,
ErrorObject::create(cx, JSEXN_WASMCOMPILEERROR, stack, filename, line, 0, nullptr, message));
if (!errorObj)
return false;
@@ -2534,17 +2534,17 @@ WebAssembly_compile(JSContext* cx, unsig
if (!task || !task->init(cx, "WebAssembly.compile"))
return false;
CallArgs callArgs = CallArgsFromVp(argc, vp);
if (!GetBufferSource(cx, callArgs, "WebAssembly.compile", &task->bytecode))
return RejectWithPendingException(cx, promise, callArgs);
- if (!StartOffThreadPromiseHelperTask(cx, Move(task)))
+ if (!StartOffThreadPromiseHelperTask(cx, std::move(task)))
return false;
callArgs.rval().setObject(*promise);
return true;
}
static bool
GetInstantiateArgs(JSContext* cx, CallArgs callArgs, MutableHandleObject firstArg,
@@ -2592,17 +2592,17 @@ WebAssembly_instantiate(JSContext* cx, u
} else {
auto task = cx->make_unique<CompileBufferTask>(cx, promise, importObj);
if (!task || !task->init(cx, "WebAssembly.instantiate"))
return false;
if (!GetBufferSource(cx, firstArg, JSMSG_WASM_BAD_BUF_MOD_ARG, &task->bytecode))
return RejectWithPendingException(cx, promise, callArgs);
- if (!StartOffThreadPromiseHelperTask(cx, Move(task)))
+ if (!StartOffThreadPromiseHelperTask(cx, std::move(task)))
return false;
}
callArgs.rval().setObject(*promise);
return true;
}
static bool
@@ -2806,17 +2806,17 @@ class CompileStreamTask : public Promise
MOZ_CRASH("unreachable");
}
void streamClosed(JS::StreamConsumer::CloseReason closeReason) override {
switch (closeReason) {
case JS::StreamConsumer::EndOfFile:
switch (streamState_.lock().get()) {
case Env: {
- SharedBytes bytecode = js_new<ShareableBytes>(Move(envBytes_));
+ SharedBytes bytecode = js_new<ShareableBytes>(std::move(envBytes_));
if (!bytecode) {
rejectAndDestroyBeforeHelperThreadStarted(JSMSG_OUT_OF_MEMORY);
return;
}
module_ = CompileBuffer(*compileArgs_, *bytecode, &compileError_, &warnings_);
setClosedAndDestroyBeforeHelperThreadStarted();
return;
}
--- a/js/src/wasm/WasmModule.cpp
+++ b/js/src/wasm/WasmModule.cpp
@@ -109,17 +109,17 @@ LinkDataTier::sizeOfExcludingThis(Malloc
symbolicLinks.sizeOfExcludingThis(mallocSizeOf);
}
void
LinkData::setTier2(UniqueLinkDataTier tier) const
{
MOZ_RELEASE_ASSERT(tier->tier == Tier::Ion && tier1_->tier == Tier::Baseline);
MOZ_RELEASE_ASSERT(!tier2_.get());
- tier2_ = Move(tier);
+ tier2_ = std::move(tier);
}
const LinkDataTier&
LinkData::tier(Tier tier) const
{
switch (tier) {
case Tier::Baseline:
if (tier1_->tier == Tier::Baseline)
@@ -212,17 +212,17 @@ Module::startTier2(const CompileArgs& ar
// hasn't been already.
UniqueTier2GeneratorTask task(js_new<Tier2GeneratorTaskImpl>(*this, args));
if (!task)
return;
tiering_.lock()->active = true;
- StartOffThreadWasmTier2Generator(Move(task));
+ StartOffThreadWasmTier2Generator(std::move(task));
}
void
Module::notifyCompilationListeners()
{
// Notify listeners without holding the lock to avoid deadlocks if the
// listener takes their own lock or reenters this Module.
@@ -245,21 +245,21 @@ Module::notifyCompilationListeners()
bool
Module::finishTier2(UniqueLinkDataTier linkData2, UniqueCodeTier tier2Arg, ModuleEnvironment* env2)
{
MOZ_ASSERT(code().bestTier() == Tier::Baseline && tier2Arg->tier() == Tier::Ion);
// Install the data in the data structures. They will not be visible
// until commitTier2().
- if (!code().setTier2(Move(tier2Arg), *bytecode_, *linkData2))
+ if (!code().setTier2(std::move(tier2Arg), *bytecode_, *linkData2))
return false;
- linkData().setTier2(Move(linkData2));
+ linkData().setTier2(std::move(linkData2));
for (uint32_t i = 0; i < elemSegments_.length(); i++)
- elemSegments_[i].setTier2(Move(env2->elemSegments[i].elemCodeRangeIndices(Tier::Ion)));
+ elemSegments_[i].setTier2(std::move(env2->elemSegments[i].elemCodeRangeIndices(Tier::Ion)));
// Before we can make tier-2 live, we need to compile tier2 versions of any
// extant tier1 lazy stubs (otherwise, tiering would break the assumption
// that any extant exported wasm function has had a lazy entry stub already
// compiled for it).
{
// We need to prevent new tier1 stubs generation until we've committed
// the newer tier2 stubs, otherwise we might not generate one tier2
@@ -489,24 +489,24 @@ Module::deserialize(const uint8_t* bytec
SharedCode code;
cursor = Code::deserialize(cursor, *bytecode, linkData, *metadata, &code);
if (!cursor)
return nullptr;
MOZ_RELEASE_ASSERT(cursor == compiledBegin + compiledSize);
MOZ_RELEASE_ASSERT(!!maybeMetadata == code->metadata().isAsmJS());
- return js_new<Module>(Move(assumptions),
+ return js_new<Module>(std::move(assumptions),
*code,
nullptr, // Serialized code is never debuggable
- Move(linkData),
- Move(imports),
- Move(exports),
- Move(dataSegments),
- Move(elemSegments),
+ std::move(linkData),
+ std::move(imports),
+ std::move(exports),
+ std::move(dataSegments),
+ std::move(elemSegments),
*bytecode);
}
/* virtual */ JSObject*
Module::createObject(JSContext* cx)
{
if (!GlobalObject::ensureConstructor(cx, cx->global(), JSProto_WebAssembly))
return nullptr;
@@ -546,17 +546,17 @@ MapFile(PRFileDesc* file, PRFileInfo* in
bool
wasm::CompiledModuleAssumptionsMatch(PRFileDesc* compiled, JS::BuildIdCharVector&& buildId)
{
PRFileInfo info;
UniqueMapping mapping = MapFile(compiled, &info);
if (!mapping)
return false;
- Assumptions assumptions(Move(buildId));
+ Assumptions assumptions(std::move(buildId));
return Module::assumptionsMatch(assumptions, mapping.get(), info.size);
}
SharedModule
wasm::DeserializeModule(PRFileDesc* bytecodeFile, PRFileDesc* maybeCompiledFile,
JS::BuildIdCharVector&& buildId, UniqueChars filename,
unsigned line)
{
@@ -581,20 +581,20 @@ wasm::DeserializeModule(PRFileDesc* byte
MutableBytes bytecode = js_new<ShareableBytes>();
if (!bytecode || !bytecode->bytes.initLengthUninitialized(bytecodeInfo.size))
return nullptr;
memcpy(bytecode->bytes.begin(), bytecodeMapping.get(), bytecodeInfo.size);
ScriptedCaller scriptedCaller;
- scriptedCaller.filename = Move(filename);
+ scriptedCaller.filename = std::move(filename);
scriptedCaller.line = line;
- MutableCompileArgs args = js_new<CompileArgs>(Assumptions(Move(buildId)), Move(scriptedCaller));
+ MutableCompileArgs args = js_new<CompileArgs>(Assumptions(std::move(buildId)), std::move(scriptedCaller));
if (!args)
return nullptr;
// The true answer to whether shared memory is enabled is provided by
// cx->realm()->creationOptions().getSharedMemoryAndAtomicsEnabled()
// where cx is the context that originated the call that caused this
// deserialization attempt to happen. We don't have that context here, so
// we assume that shared memory is enabled; we will catch a wrong assumption
@@ -1236,25 +1236,25 @@ Module::instantiate(JSContext* cx,
ReportOutOfMemory(cx);
return false;
}
UniqueMetadataTier metadataTier = js::MakeUnique<MetadataTier>(tier);
if (!metadataTier || !metadataTier->clone(metadata(tier)))
return false;
- auto codeTier = js::MakeUnique<CodeTier>(Move(metadataTier), Move(segment));
+ auto codeTier = js::MakeUnique<CodeTier>(std::move(metadataTier), std::move(segment));
if (!codeTier)
return false;
JumpTables jumpTables;
if (!jumpTables.init(CompileMode::Once, codeTier->segment(), metadata(tier).codeRanges))
return false;
- MutableCode debugCode = js_new<Code>(Move(codeTier), metadata(), Move(jumpTables));
+ MutableCode debugCode = js_new<Code>(std::move(codeTier), metadata(), std::move(jumpTables));
if (!debugCode || !debugCode->initialize(*bytecode_, linkData(tier))) {
ReportOutOfMemory(cx);
return false;
}
code = debugCode;
}
}
@@ -1280,20 +1280,20 @@ Module::instantiate(JSContext* cx,
bool binarySource = cx->realm()->debuggerObservesBinarySource();
auto debug = cx->make_unique<DebugState>(code, maybeBytecode, binarySource);
if (!debug)
return false;
instance.set(WasmInstanceObject::create(cx,
code,
- Move(debug),
- Move(tlsData),
+ std::move(debug),
+ std::move(tlsData),
memory,
- Move(tables),
+ std::move(tables),
funcImports,
metadata().globals,
globalImportValues,
globalObjs,
instanceProto));
if (!instance)
return false;
--- a/js/src/wasm/WasmModule.h
+++ b/js/src/wasm/WasmModule.h
@@ -82,17 +82,17 @@ typedef UniquePtr<LinkDataTier> UniqueLi
class LinkData
{
UniqueLinkDataTier tier1_; // Always present
mutable UniqueLinkDataTier tier2_; // Access only if hasTier2() is true
public:
LinkData() {}
- explicit LinkData(UniqueLinkDataTier tier) : tier1_(Move(tier)) {}
+ explicit LinkData(UniqueLinkDataTier tier) : tier1_(std::move(tier)) {}
void setTier2(UniqueLinkDataTier linkData) const;
const LinkDataTier& tier(Tier tier) const;
WASM_DECLARE_SERIALIZABLE(LinkData)
};
// Contains the locked tiering state of a Module: whether there is an active
@@ -166,24 +166,24 @@ class Module : public JS::WasmModule
const Code& code,
UniqueConstBytes unlinkedCodeForDebugging,
LinkData&& linkData,
ImportVector&& imports,
ExportVector&& exports,
DataSegmentVector&& dataSegments,
ElemSegmentVector&& elemSegments,
const ShareableBytes& bytecode)
- : assumptions_(Move(assumptions)),
+ : assumptions_(std::move(assumptions)),
code_(&code),
- unlinkedCodeForDebugging_(Move(unlinkedCodeForDebugging)),
- linkData_(Move(linkData)),
- imports_(Move(imports)),
- exports_(Move(exports)),
- dataSegments_(Move(dataSegments)),
- elemSegments_(Move(elemSegments)),
+ unlinkedCodeForDebugging_(std::move(unlinkedCodeForDebugging)),
+ linkData_(std::move(linkData)),
+ imports_(std::move(imports)),
+ exports_(std::move(exports)),
+ dataSegments_(std::move(dataSegments)),
+ elemSegments_(std::move(elemSegments)),
bytecode_(&bytecode),
tiering_(mutexid::WasmModuleTieringLock),
codeIsBusy_(false)
{
MOZ_ASSERT_IF(metadata().debugEnabled, unlinkedCodeForDebugging_);
}
~Module() override { /* Note: can be called on any thread */ }
--- a/js/src/wasm/WasmTable.cpp
+++ b/js/src/wasm/WasmTable.cpp
@@ -28,17 +28,17 @@
using namespace js;
using namespace js::wasm;
using mozilla::CheckedInt;
Table::Table(JSContext* cx, const TableDesc& desc, HandleWasmTableObject maybeObject,
UniqueByteArray array)
: maybeObject_(maybeObject),
observers_(cx->zone()),
- array_(Move(array)),
+ array_(std::move(array)),
kind_(desc.kind),
length_(desc.limits.initial),
maximum_(desc.limits.maximum),
external_(desc.external)
{}
/* static */ SharedTable
Table::create(JSContext* cx, const TableDesc& desc, HandleWasmTableObject maybeObject)
@@ -49,17 +49,17 @@ Table::create(JSContext* cx, const Table
UniqueByteArray array;
if (desc.external)
array.reset((uint8_t*)cx->pod_calloc<ExternalTableElem>(desc.limits.initial));
else
array.reset((uint8_t*)cx->pod_calloc<void*>(desc.limits.initial));
if (!array)
return nullptr;
- return SharedTable(cx->new_<Table>(cx, desc, maybeObject, Move(array)));
+ return SharedTable(cx->new_<Table>(cx, desc, maybeObject, std::move(array)));
}
void
Table::tracePrivate(JSTracer* trc)
{
// If this table has a WasmTableObject, then this method is only called by
// WasmTableObject's trace hook so maybeObject_ must already be marked.
// TraceEdge is called so that the pointer can be updated during a moving
--- a/js/src/wasm/WasmTextToBinary.cpp
+++ b/js/src/wasm/WasmTextToBinary.cpp
@@ -1885,24 +1885,24 @@ ParseBlock(WasmParseContext& c, Op op, b
if (!inParens) {
if (!c.ts.match(WasmToken::End, c.error))
return nullptr;
if (!MaybeMatchName(c, name))
return nullptr;
}
- AstBlock* result = new(c.lifo) AstBlock(op, type, name, Move(exprs));
+ AstBlock* result = new(c.lifo) AstBlock(op, type, name, std::move(exprs));
if (!result)
return nullptr;
if (op == Op::Loop && !otherName.empty()) {
if (!exprs.append(result))
return nullptr;
- result = new(c.lifo) AstBlock(Op::Block, type, otherName, Move(exprs));
+ result = new(c.lifo) AstBlock(Op::Block, type, otherName, std::move(exprs));
}
return result;
}
static AstBranch*
ParseBranch(WasmParseContext& c, Op op, bool inParens)
{
@@ -1963,17 +1963,17 @@ ParseCall(WasmParseContext& c, bool inPa
return nullptr;
AstExprVector args(c.lifo);
if (inParens) {
if (!ParseArgs(c, &args))
return nullptr;
}
- return new(c.lifo) AstCall(Op::Call, ExprType::Void, func, Move(args));
+ return new(c.lifo) AstCall(Op::Call, ExprType::Void, func, std::move(args));
}
static AstCallIndirect*
ParseCallIndirect(WasmParseContext& c, bool inParens)
{
AstRef sig;
if (!c.ts.matchRef(&sig, c.error))
return nullptr;
@@ -1990,17 +1990,17 @@ ParseCallIndirect(WasmParseContext& c, b
index = args.popCopy();
} else {
index = new(c.lifo) AstPop();
}
if (!index)
return nullptr;
- return new(c.lifo) AstCallIndirect(sig, ExprType::Void, Move(args), index);
+ return new(c.lifo) AstCallIndirect(sig, ExprType::Void, std::move(args), index);
}
static uint_fast8_t
CountLeadingZeroes4(uint8_t x)
{
MOZ_ASSERT((x & -0x10) == 0);
return CountLeadingZeroes32(x) - 28;
}
@@ -2528,17 +2528,17 @@ ParseIf(WasmParseContext& c, bool inPare
} else {
if (!c.ts.match(WasmToken::End, c.error))
return nullptr;
if (!MaybeMatchName(c, name))
return nullptr;
}
}
- return new(c.lifo) AstIf(type, cond, name, Move(thenExprs), Move(elseExprs));
+ return new(c.lifo) AstIf(type, cond, name, std::move(thenExprs), std::move(elseExprs));
}
static bool
ParseLoadStoreAddress(WasmParseContext& c, int32_t* offset, uint32_t* alignLog2, AstExpr** base,
bool inParens)
{
*offset = 0;
if (c.ts.getIf(WasmToken::Offset)) {
@@ -2949,17 +2949,17 @@ ParseBranchTable(WasmParseContext& c, bo
index = ParseExprInsideParens(c);
if (!index)
return nullptr;
if (!c.ts.match(WasmToken::CloseParen, c.error))
return nullptr;
}
}
- return new(c.lifo) AstBranchTable(*index, def, Move(table), value);
+ return new(c.lifo) AstBranchTable(*index, def, std::move(table), value);
}
static AstGrowMemory*
ParseGrowMemory(WasmParseContext& c, bool inParens)
{
AstExpr* operand = ParseExpr(c, inParens);
if (!operand)
return nullptr;
@@ -3211,32 +3211,32 @@ ParseFuncSig(WasmParseContext& c, AstSig
default:
c.ts.generateError(token, c.error);
return false;
}
if (!c.ts.match(WasmToken::CloseParen, c.error))
return false;
}
- *sig = AstSig(Move(args), result);
+ *sig = AstSig(std::move(args), result);
return true;
}
static bool
ParseFuncType(WasmParseContext& c, AstRef* ref, AstModule* module)
{
if (!MaybeParseTypeUse(c, ref))
return false;
if (ref->isInvalid()) {
AstSig sig(c.lifo);
if (!ParseFuncSig(c, &sig))
return false;
uint32_t sigIndex;
- if (!module->declare(Move(sig), &sigIndex))
+ if (!module->declare(std::move(sig), &sigIndex))
return false;
ref->setIndex(sigIndex);
}
return true;
}
static bool
@@ -3321,22 +3321,22 @@ ParseFunc(WasmParseContext& c, AstModule
return false;
}
if (!ParseExprList(c, &body))
return false;
if (sigRef.isInvalid()) {
uint32_t sigIndex;
- if (!module->declare(AstSig(Move(args), result), &sigIndex))
+ if (!module->declare(AstSig(std::move(args), result), &sigIndex))
return false;
sigRef.setIndex(sigIndex);
}
- auto* func = new(c.lifo) AstFunc(funcName, sigRef, Move(vars), Move(locals), Move(body));
+ auto* func = new(c.lifo) AstFunc(funcName, sigRef, std::move(vars), std::move(locals), std::move(body));
return func && module->append(func);
}
static AstSig*
ParseTypeDef(WasmParseContext& c)
{
AstName name = c.ts.getIfName();
@@ -3347,17 +3347,17 @@ ParseTypeDef(WasmParseContext& c)
AstSig sig(c.lifo);
if (!ParseFuncSig(c, &sig))
return nullptr;
if (!c.ts.match(WasmToken::CloseParen, c.error))
return nullptr;
- return new(c.lifo) AstSig(name, Move(sig));
+ return new(c.lifo) AstSig(name, std::move(sig));
}
static bool
MaybeParseOwnerIndex(WasmParseContext& c)
{
if (c.ts.peek().kind() == WasmToken::Index) {
WasmToken elemIndex = c.ts.get();
if (elemIndex.index()) {
@@ -3397,17 +3397,17 @@ ParseDataSegment(WasmParseContext& c)
AstNameVector fragments(c.lifo);
WasmToken text;
while (c.ts.getIf(WasmToken::Text, &text)) {
if (!fragments.append(text.text()))
return nullptr;
}
- return new(c.lifo) AstDataSegment(offset, Move(fragments));
+ return new(c.lifo) AstDataSegment(offset, std::move(fragments));
}
static bool
ParseLimits(WasmParseContext& c, Limits* limits, Shareable allowShared)
{
WasmToken initial;
if (!c.ts.match(WasmToken::Index, &initial, c.error))
return false;
@@ -3481,17 +3481,17 @@ ParseMemory(WasmParseContext& c, AstModu
totalLength += data.text().length();
}
if (fragments.length()) {
AstExpr* offset = new(c.lifo) AstConst(Val(uint32_t(0)));
if (!offset)
return false;
- AstDataSegment* segment = new(c.lifo) AstDataSegment(offset, Move(fragments));
+ AstDataSegment* segment = new(c.lifo) AstDataSegment(offset, std::move(fragments));
if (!segment || !module->append(segment))
return false;
pages = AlignBytes<size_t>(totalLength, PageSize) / PageSize;
if (pages != uint32_t(pages))
return false;
}
@@ -3637,17 +3637,17 @@ ParseImport(WasmParseContext& c, AstModu
}
if (sigRef.isInvalid()) {
AstSig sig(c.lifo);
if (!ParseFuncSig(c, &sig))
return nullptr;
uint32_t sigIndex;
- if (!module->declare(Move(sig), &sigIndex))
+ if (!module->declare(std::move(sig), &sigIndex))
return nullptr;
sigRef.setIndex(sigIndex);
}
return new(c.lifo) AstImport(name, moduleName.text(), fieldName.text(), sigRef);
}
static AstExport*
@@ -3795,17 +3795,17 @@ ParseTable(WasmParseContext& c, WasmToke
if (!module->addTable(name, Limits(numElements, Some(numElements), Shareable::False)))
return false;
auto* zero = new(c.lifo) AstConst(Val(uint32_t(0)));
if (!zero)
return false;
- AstElemSegment* segment = new(c.lifo) AstElemSegment(zero, Move(elems));
+ AstElemSegment* segment = new(c.lifo) AstElemSegment(zero, std::move(elems));
return segment && module->append(segment);
}
static AstElemSegment*
ParseElemSegment(WasmParseContext& c)
{
if (!MaybeParseOwnerIndex(c))
return nullptr;
@@ -3817,17 +3817,17 @@ ParseElemSegment(WasmParseContext& c)
AstRefVector elems(c.lifo);
AstRef elem;
while (c.ts.getIfRef(&elem)) {
if (!elems.append(elem))
return nullptr;
}
- return new(c.lifo) AstElemSegment(offset, Move(elems));
+ return new(c.lifo) AstElemSegment(offset, std::move(elems));
}
static bool
ParseGlobal(WasmParseContext& c, AstModule* module)
{
AstName name = c.ts.getIfName();
WasmToken typeToken;
@@ -3887,17 +3887,17 @@ ParseBinaryModule(WasmParseContext& c, A
AstNameVector fragments(c.lifo);
WasmToken text;
while (c.ts.getIf(WasmToken::Text, &text)) {
if (!fragments.append(text.text()))
return nullptr;
}
- auto* data = new(c.lifo) AstDataSegment(nullptr, Move(fragments));
+ auto* data = new(c.lifo) AstDataSegment(nullptr, std::move(fragments));
if (!data || !module->append(data))
return nullptr;
return module;
}
static AstModule*
ParseModule(const char16_t* text, uintptr_t stackLimit, LifoAlloc& lifo, UniqueChars* error,
--- a/js/src/wasm/WasmTypes.cpp
+++ b/js/src/wasm/WasmTypes.cpp
@@ -347,24 +347,24 @@ Import::deserialize(const uint8_t* curso
size_t
Import::sizeOfExcludingThis(MallocSizeOf mallocSizeOf) const
{
return module.sizeOfExcludingThis(mallocSizeOf) +
field.sizeOfExcludingThis(mallocSizeOf);
}
Export::Export(UniqueChars fieldName, uint32_t index, DefinitionKind kind)
- : fieldName_(Move(fieldName))
+ : fieldName_(std::move(fieldName))
{
pod.kind_ = kind;
pod.index_ = index;
}
Export::Export(UniqueChars fieldName, DefinitionKind kind)
- : fieldName_(Move(fieldName))
+ : fieldName_(std::move(fieldName))
{
pod.kind_ = kind;
pod.index_ = 0;
}
uint32_t
Export::funcIndex() const
{
@@ -441,17 +441,17 @@ size_t
ElemSegment::sizeOfExcludingThis(MallocSizeOf mallocSizeOf) const
{
return elemFuncIndices.sizeOfExcludingThis(mallocSizeOf) +
elemCodeRangeIndices(Tier::Serialized).sizeOfExcludingThis(mallocSizeOf);
}
Assumptions::Assumptions(JS::BuildIdCharVector&& buildId)
: cpuId(GetCPUID()),
- buildId(Move(buildId))
+ buildId(std::move(buildId))
{}
Assumptions::Assumptions()
: cpuId(GetCPUID()),
buildId()
{}
bool
--- a/js/src/wasm/WasmTypes.h
+++ b/js/src/wasm/WasmTypes.h
@@ -694,17 +694,17 @@ typedef Vector<Val, 0, SystemAllocPolicy
class Sig
{
ValTypeVector args_;
ExprType ret_;
public:
Sig() : args_(), ret_(ExprType::Void) {}
- Sig(ValTypeVector&& args, ExprType ret) : args_(Move(args)), ret_(ret) {}
+ Sig(ValTypeVector&& args, ExprType ret) : args_(std::move(args)), ret_(ret) {}
MOZ_MUST_USE bool clone(const Sig& rhs) {
ret_ = rhs.ret_;
MOZ_ASSERT(args_.empty());
return args_.appendAll(rhs.args_);
}
ValType arg(unsigned i) const { return args_[i]; }
@@ -805,17 +805,17 @@ class InitExpr
};
// CacheableChars is used to cacheably store UniqueChars.
struct CacheableChars : UniqueChars
{
CacheableChars() = default;
explicit CacheableChars(char* ptr) : UniqueChars(ptr) {}
- MOZ_IMPLICIT CacheableChars(UniqueChars&& rhs) : UniqueChars(Move(rhs)) {}
+ MOZ_IMPLICIT CacheableChars(UniqueChars&& rhs) : UniqueChars(std::move(rhs)) {}
WASM_DECLARE_SERIALIZABLE(CacheableChars)
};
typedef Vector<CacheableChars, 0, SystemAllocPolicy> CacheableCharsVector;
// Import describes a single wasm import. An ImportVector describes all
// of a single module's imports.
//
@@ -825,17 +825,17 @@ typedef Vector<CacheableChars, 0, System
struct Import
{
CacheableChars module;
CacheableChars field;
DefinitionKind kind;
Import() = default;
Import(UniqueChars&& module, UniqueChars&& field, DefinitionKind kind)
- : module(Move(module)), field(Move(field)), kind(kind)
+ : module(std::move(module)), field(std::move(field)), kind(kind)
{}
WASM_DECLARE_SERIALIZABLE(Import)
};
typedef Vector<Import, 0, SystemAllocPolicy> ImportVector;
// Export describes the export of a definition in a Module to a field in the
@@ -1003,17 +1003,17 @@ struct ElemSegment
uint32_t tableIndex;
InitExpr offset;
Uint32Vector elemFuncIndices;
Uint32Vector elemCodeRangeIndices1_;
mutable Uint32Vector elemCodeRangeIndices2_;
ElemSegment() = default;
ElemSegment(uint32_t tableIndex, InitExpr offset, Uint32Vector&& elemFuncIndices)
- : tableIndex(tableIndex), offset(offset), elemFuncIndices(Move(elemFuncIndices))
+ : tableIndex(tableIndex), offset(offset), elemFuncIndices(std::move(elemFuncIndices))
{}
Uint32Vector& elemCodeRangeIndices(Tier t) {
switch (t) {
case Tier::Baseline:
return elemCodeRangeIndices1_;
case Tier::Ion:
return elemCodeRangeIndices2_;
@@ -1030,17 +1030,17 @@ struct ElemSegment
return elemCodeRangeIndices2_;
default:
MOZ_CRASH("No such tier");
}
}
void setTier2(Uint32Vector&& elemCodeRangeIndices) const {
MOZ_ASSERT(elemCodeRangeIndices2_.length() == 0);
- elemCodeRangeIndices2_ = Move(elemCodeRangeIndices);
+ elemCodeRangeIndices2_ = std::move(elemCodeRangeIndices);
}
WASM_DECLARE_SERIALIZABLE(ElemSegment)
};
// The ElemSegmentVector is laid out in a deterministic order.
typedef Vector<ElemSegment, 0, SystemAllocPolicy> ElemSegmentVector;
@@ -1098,19 +1098,19 @@ class SigIdDesc
// that compares this signature's id or, at instantiation what signature ids to
// allocate in the global hash and where to put them.
struct SigWithId : Sig
{
SigIdDesc id;
SigWithId() = default;
- explicit SigWithId(Sig&& sig) : Sig(Move(sig)), id() {}
- SigWithId(Sig&& sig, SigIdDesc id) : Sig(Move(sig)), id(id) {}
- void operator=(Sig&& rhs) { Sig::operator=(Move(rhs)); }
+ explicit SigWithId(Sig&& sig) : Sig(std::move(sig)), id() {}
+ SigWithId(Sig&& sig, SigIdDesc id) : Sig(std::move(sig)), id(id) {}
+ void operator=(Sig&& rhs) { Sig::operator=(std::move(rhs)); }
WASM_DECLARE_SERIALIZABLE(SigWithId)
};
typedef Vector<SigWithId, 0, SystemAllocPolicy> SigWithIdVector;
typedef Vector<const SigWithId*, 0, SystemAllocPolicy> SigWithIdPtrVector;
// A wasm::Trap represents a wasm-defined trap that can occur during execution
--- a/js/src/wasm/WasmValidate.cpp
+++ b/js/src/wasm/WasmValidate.cpp
@@ -57,28 +57,28 @@ Decoder::warnf(const char* msg, ...)
va_list ap;
va_start(ap, msg);
UniqueChars str(JS_vsmprintf(msg, ap));
va_end(ap);
if (!str)
return;
- Unused << warnings_->append(Move(str));
+ Unused << warnings_->append(std::move(str));
}
bool
Decoder::fail(size_t errorOffset, const char* msg)
{
MOZ_ASSERT(error_);
UniqueChars strWithOffset(JS_smprintf("at offset %zu: %s", errorOffset, msg));
if (!strWithOffset)
return false;
- *error_ = Move(strWithOffset);
+ *error_ = std::move(strWithOffset);
return false;
}
bool
Decoder::readSectionHeader(uint8_t* id, SectionRange* range)
{
if (!readFixedU8(id))
return false;
@@ -1117,17 +1117,17 @@ DecodeTypeSection(Decoder& d, ModuleEnvi
if (numRets == 1) {
ValType type;
if (!DecodeValType(d, ModuleKind::Wasm, env->gcTypesEnabled, &type))
return false;
result = ToExprType(type);
}
- env->sigs[sigIndex] = Sig(Move(args), result);
+ env->sigs[sigIndex] = Sig(std::move(args), result);
}
return d.finishSection(*range, "type");
}
static UniqueChars
DecodeName(Decoder& d)
{
@@ -1363,17 +1363,17 @@ DecodeImport(Decoder& d, ModuleEnvironme
if (env->globals.length() > MaxGlobals)
return d.fail("too many globals");
break;
}
default:
return d.fail("unsupported import kind");
}
- return env->imports.emplaceBack(Move(moduleName), Move(funcName), importKind);
+ return env->imports.emplaceBack(std::move(moduleName), std::move(funcName), importKind);
}
static bool
DecodeImportSection(Decoder& d, ModuleEnvironment* env)
{
MaybeSectionRange range;
if (!d.startSection(SectionId::Import, env, &range, "import"))
return false;
@@ -1596,17 +1596,17 @@ DecodeExportName(Decoder& d, CStringSet*
if (p) {
d.fail("duplicate export");
return nullptr;
}
if (!dupSet->add(p, exportName.get()))
return nullptr;
- return Move(exportName);
+ return std::move(exportName);
}
static bool
DecodeExport(Decoder& d, ModuleEnvironment* env, CStringSet* dupSet)
{
UniqueChars fieldName = DecodeExportName(d, dupSet);
if (!fieldName)
return false;
@@ -1619,55 +1619,55 @@ DecodeExport(Decoder& d, ModuleEnvironme
case DefinitionKind::Function: {
uint32_t funcIndex;
if (!d.readVarU32(&funcIndex))
return d.fail("expected function index");
if (funcIndex >= env->numFuncs())
return d.fail("exported function index out of bounds");
- return env->exports.emplaceBack(Move(fieldName), funcIndex, DefinitionKind::Function);
+ return env->exports.emplaceBack(std::move(fieldName), funcIndex, DefinitionKind::Function);
}
case DefinitionKind::Table: {
uint32_t tableIndex;
if (!d.readVarU32(&tableIndex))
return d.fail("expected table index");
if (tableIndex >= env->tables.length())
return d.fail("exported table index out of bounds");
MOZ_ASSERT(env->tables.length() == 1);
env->tables[0].external = true;
- return env->exports.emplaceBack(Move(fieldName), DefinitionKind::Table);
+ return env->exports.emplaceBack(std::move(fieldName), DefinitionKind::Table);
}
case DefinitionKind::Memory: {
uint32_t memoryIndex;
if (!d.readVarU32(&memoryIndex))
return d.fail("expected memory index");
if (memoryIndex > 0 || !env->usesMemory())
return d.fail("exported memory index out of bounds");
- return env->exports.emplaceBack(Move(fieldName), DefinitionKind::Memory);
+ return env->exports.emplaceBack(std::move(fieldName), DefinitionKind::Memory);
}
case DefinitionKind::Global: {
uint32_t globalIndex;
if (!d.readVarU32(&globalIndex))
return d.fail("expected global index");
if (globalIndex >= env->globals.length())
return d.fail("exported global index out of bounds");
GlobalDesc* global = &env->globals[globalIndex];
global->setIsExport();
if (!GlobalIsJSCompatible(d, global->type(), global->isMutable()))
return false;
- return env->exports.emplaceBack(Move(fieldName), globalIndex, DefinitionKind::Global);
+ return env->exports.emplaceBack(std::move(fieldName), globalIndex, DefinitionKind::Global);
}
default:
return d.fail("unexpected export kind");
}
MOZ_CRASH("unreachable");
}
@@ -1769,17 +1769,17 @@ DecodeElemSection(Decoder& d, ModuleEnvi
for (uint32_t i = 0; i < numElems; i++) {
if (!d.readVarU32(&elemFuncIndices[i]))
return d.fail("failed to read element function index");
if (elemFuncIndices[i] >= env->numFuncs())
return d.fail("table element out of range");
}
- if (!env->elemSegments.emplaceBack(0, offset, Move(elemFuncIndices)))
+ if (!env->elemSegments.emplaceBack(0, offset, std::move(elemFuncIndices)))
return false;
env->tables[env->elemSegments.back().tableIndex].external = true;
}
return d.finishSection(*range, "elem");
}
@@ -2015,17 +2015,17 @@ DecodeFunctionNameSubsection(Decoder& d,
funcNames[funcIndex] = funcName;
}
if (!d.finishNameSubsection(*endOffset))
return false;
// To encourage fully valid function names subsections; only save names if
// the entire subsection decoded correctly.
- env->funcNames = Move(funcNames);
+ env->funcNames = std::move(funcNames);
return true;
}
static bool
DecodeNameSection(Decoder& d, ModuleEnvironment* env)
{
MaybeSectionRange range;
if (!d.startCustomSection(NameSectionName, env, &range))
--- a/js/xpconnect/loader/ScriptCacheActors.cpp
+++ b/js/xpconnect/loader/ScriptCacheActors.cpp
@@ -81,17 +81,17 @@ ScriptCacheParent::Recv__delete__(nsTArr
// Merge the child's script data with the parent's.
auto parent = static_cast<dom::ContentParent*>(Manager());
auto processType = ScriptPreloader::GetChildProcessType(parent->GetRemoteType());
auto& cache = ScriptPreloader::GetChildSingleton();
for (auto& script : scripts) {
cache.NoteScript(script.url(), script.cachePath(), processType,
- Move(script.xdrData()), script.loadTime());
+ std::move(script.xdrData()), script.loadTime());
}
return IPC_OK();
}
void
ScriptCacheParent::ActorDestroy(ActorDestroyReason aWhy)
{}
--- a/js/xpconnect/loader/ScriptPreloader-inl.h
+++ b/js/xpconnect/loader/ScriptPreloader-inl.h
@@ -225,17 +225,17 @@ class HashElemIter
T& hash_;
Matcher<ElemType>* matcher_;
Maybe<Iterator> iter_;
public:
explicit HashElemIter(T& hash, Matcher<ElemType>* matcher = nullptr)
: hash_(hash), matcher_(matcher)
{
- iter_.emplace(Move(hash.Iter()));
+ iter_.emplace(std::move(hash.Iter()));
}
class Elem
{
friend class HashElemIter<T>;
HashElemIter<T>& iter_;
bool done_;
--- a/js/xpconnect/loader/ScriptPreloader.cpp
+++ b/js/xpconnect/loader/ScriptPreloader.cpp
@@ -379,17 +379,17 @@ ScriptPreloader::GetCacheFile(const nsAS
nsCOMPtr<nsIFile> cacheFile;
MOZ_TRY(mProfD->Clone(getter_AddRefs(cacheFile)));
MOZ_TRY(cacheFile->AppendNative(NS_LITERAL_CSTRING("startupCache")));
Unused << cacheFile->Create(nsIFile::DIRECTORY_TYPE, 0777);
MOZ_TRY(cacheFile->Append(mBaseName + suffix));
- return Move(cacheFile);
+ return std::move(cacheFile);
}
static const uint8_t MAGIC[] = "mozXDRcachev001";
Result<Ok, nsresult>
ScriptPreloader::OpenCache()
{
MOZ_TRY(NS_GetSpecialDirectory("ProfLDS", getter_AddRefs(mProfD)));
@@ -535,17 +535,17 @@ ScriptPreloader::InitCacheInternal(JS::H
mScripts.Put(script->mCachePath, script.get());
Unused << script.release();
}
if (buf.error()) {
return Err(NS_ERROR_UNEXPECTED);
}
- mPendingScripts = Move(scripts);
+ mPendingScripts = std::move(scripts);
cleanup.release();
}
DecodeNextBatch(OFF_THREAD_FIRST_CHUNK_SIZE, scope);
return Ok();
}
void
--- a/js/xpconnect/loader/URLPreloader.cpp
+++ b/js/xpconnect/loader/URLPreloader.cpp
@@ -172,17 +172,17 @@ URLPreloader::GetCacheFile(const nsAStri
nsCOMPtr<nsIFile> cacheFile;
MOZ_TRY(mProfD->Clone(getter_AddRefs(cacheFile)));
MOZ_TRY(cacheFile->AppendNative(NS_LITERAL_CSTRING("startupCache")));
Unused << cacheFile->Create(nsIFile::DIRECTORY_TYPE, 0777);
MOZ_TRY(cacheFile->Append(NS_LITERAL_STRING("urlCache") + suffix));
- return Move(cacheFile);
+ return std::move(cacheFile);
}
static const uint8_t URL_MAGIC[] = "mozURLcachev002";
Result<nsCOMPtr<nsIFile>, nsresult>
URLPreloader::FindCacheFile()
{
nsCOMPtr<nsIFile> cacheFile;
@@ -195,17 +195,17 @@ URLPreloader::FindCacheFile()
} else {
MOZ_TRY(cacheFile->SetLeafName(NS_LITERAL_STRING("urlCache-current.bin")));
MOZ_TRY(cacheFile->Exists(&exists));
if (!exists) {
return Err(NS_ERROR_FILE_NOT_FOUND);
}
}
- return Move(cacheFile);
+ return std::move(cacheFile);
}
Result<Ok, nsresult>
URLPreloader::WriteCache()
{
MOZ_ASSERT(!NS_IsMainThread());
// The script preloader might call us a second time, if it has to re-write
@@ -619,21 +619,21 @@ URLPreloader::ShallowSizeOfIncludingThis
Result<FileLocation, nsresult>
URLPreloader::CacheKey::ToFileLocation()
{
if (mType == TypeFile) {
nsCOMPtr<nsIFile> file;
MOZ_TRY(NS_NewLocalFile(NS_ConvertUTF8toUTF16(mPath), false,
getter_AddRefs(file)));
- return Move(FileLocation(file));
+ return std::move(FileLocation(file));
}
RefPtr<nsZipArchive> zip = Archive();
- return Move(FileLocation(zip, mPath.get()));
+ return std::move(FileLocation(zip, mPath.get()));
}
Result<const nsCString, nsresult>
URLPreloader::URLEntry::Read()
{
FileLocation location;
MOZ_TRY_VAR(location, ToFileLocation());
@@ -649,17 +649,17 @@ URLPreloader::URLEntry::ReadLocation(Fil
uint32_t size;
MOZ_TRY(data.GetSize(&size));
nsCString result;
result.SetLength(size);
MOZ_TRY(data.Copy(result.BeginWriting(), size));
- return Move(result);
+ return std::move(result);
}
Result<const nsCString, nsresult>
URLPreloader::URLEntry::ReadOrWait(ReadType readType)
{
auto now = TimeStamp::Now();
LOG(Info, "Reading %s\n", mPath.get());
auto cleanup = MakeScopeExit([&] () {
--- a/js/xpconnect/loader/mozJSComponentLoader.cpp
+++ b/js/xpconnect/loader/mozJSComponentLoader.cpp
@@ -284,17 +284,17 @@ ReportOnCallerUTF8(JSCLContextHelper& he
nsCString location;
MOZ_TRY(info.GetLocation(location));
UniqueChars buf = JS_smprintf(format, location.get(), args...);
if (!buf) {
return NS_ERROR_OUT_OF_MEMORY;
}
- helper.reportErrorAfterPop(Move(buf));
+ helper.reportErrorAfterPop(std::move(buf));
return NS_ERROR_FAILURE;
}
#undef BEGIN_ENSURE
#undef ENSURE_DEPS
#undef ENSURE_DEP
mozJSComponentLoader::~mozJSComponentLoader()
@@ -769,17 +769,17 @@ ReadScript(ComponentLoaderInfo& aInfo)
if (!str.SetLength(len, fallible))
return Err(NS_ERROR_OUT_OF_MEMORY);
/* read the file in one swoop */
MOZ_TRY(scriptStream->Read(str.BeginWriting(), len, &bytesRead));
if (bytesRead != len)
return Err(NS_BASE_STREAM_OSERROR);
- return Move(str);
+ return std::move(str);
}
nsresult
mozJSComponentLoader::ObjectForLocation(ComponentLoaderInfo& aInfo,
nsIFile* aComponentFile,
MutableHandleObject aObject,
MutableHandleScript aTableScript,
char** aLocation,
@@ -1477,10 +1477,10 @@ JSCLContextHelper::~JSCLContextHelper()
JS_ReportErrorUTF8(mContext, "%s", mBuf.get());
}
}
void
JSCLContextHelper::reportErrorAfterPop(UniqueChars&& buf)
{
MOZ_ASSERT(!mBuf, "Already called reportErrorAfterPop");
- mBuf = Move(buf);
+ mBuf = std::move(buf);
}
--- a/js/xpconnect/loader/mozJSLoaderUtils.cpp
+++ b/js/xpconnect/loader/mozJSLoaderUtils.cpp
@@ -61,12 +61,12 @@ WriteCachedScript(StartupCache* cache, n
size_t size = buffer.length();
if (size > UINT32_MAX)
return NS_ERROR_FAILURE;
// Move the vector buffer into a unique pointer buffer.
UniquePtr<char[]> buf(reinterpret_cast<char*>(buffer.extractOrCopyRawBuffer()));
nsresult rv = cache->PutBuffer(PromiseFlatCString(uri).get(),
- Move(buf),
+ std::move(buf),
size);
return rv;
}
--- a/js/xpconnect/src/XPCJSRuntime.cpp
+++ b/js/xpconnect/src/XPCJSRuntime.cpp
@@ -2866,17 +2866,17 @@ XPCJSRuntime::Initialize(JSContext* cx)
// code in memory. When the JS engine is asked to provide the source for a
// function compiled with LAZY_SOURCE, it calls SourceHook to load it.
///
// Note we do have to retain the source code in memory for scripts compiled in
// isRunOnce mode and compiled function bodies (from
// JS::CompileFunction). In practice, this means content scripts and event
// handlers.
mozilla::UniquePtr<XPCJSSourceHook> hook(new XPCJSSourceHook);
- js::SetSourceHook(cx, Move(hook));
+ js::SetSourceHook(cx, std::move(hook));
// Register memory reporters and distinguished amount functions.
RegisterStrongMemoryReporter(new JSMainRuntimeRealmsReporter());
RegisterStrongMemoryReporter(new JSMainRuntimeTemporaryPeakReporter());
RegisterJSMainRuntimeGCHeapDistinguishedAmount(JSMainRuntimeGCHeapDistinguishedAmount);
RegisterJSMainRuntimeTemporaryPeakDistinguishedAmount(JSMainRuntimeTemporaryPeakDistinguishedAmount);
RegisterJSMainRuntimeRealmsSystemDistinguishedAmount(JSMainRuntimeRealmsSystemDistinguishedAmount);
RegisterJSMainRuntimeRealmsUserDistinguishedAmount(JSMainRuntimeRealmsUserDistinguishedAmount);
--- a/js/xpconnect/src/XPCShellImpl.cpp
+++ b/js/xpconnect/src/XPCShellImpl.cpp
@@ -496,31 +496,31 @@ Options(JSContext* cx, unsigned argc, Va
JS_ReportErrorUTF8(cx, "unknown option name '%s'. The valid names are "
"strict, werror, and strict_mode.", opt.ptr());
return false;
}
}
UniqueChars names;
if (oldContextOptions.extraWarnings()) {
- names = JS_sprintf_append(Move(names), "%s", "strict");
+ names = JS_sprintf_append(std::move(names), "%s", "strict");
if (!names) {
JS_ReportOutOfMemory(cx);
return false;
}
}
if (oldContextOptions.werror()) {
- names = JS_sprintf_append(Move(names), "%s%s", names ? "," : "", "werror");
+ names = JS_sprintf_append(std::move(names), "%s%s", names ? "," : "", "werror");
if (!names) {
JS_ReportOutOfMemory(cx);
return false;
}
}
if (names && oldContextOptions.strictMode()) {
- names = JS_sprintf_append(Move(names), "%s%s", names ? "," : "", "strict_mode");
+ names = JS_sprintf_append(std::move(names), "%s%s", names ? "," : "", "strict_mode");
if (!names) {
JS_ReportOutOfMemory(cx);
return false;
}
}
str = JS_NewStringCopyZ(cx, names.get());
if (!str)
--- a/js/xpconnect/src/XPCWrappedNative.cpp
+++ b/js/xpconnect/src/XPCWrappedNative.cpp
@@ -1808,34 +1808,34 @@ XPCWrappedNative::ToString(XPCWrappedNat
UniqueChars sz;
UniqueChars name;
nsCOMPtr<nsIXPCScriptable> scr = GetScriptable();
if (scr)
name = JS_smprintf("%s", scr->GetJSClass()->name);
if (to) {
const char* fmt = name ? " (%s)" : "%s";
- name = JS_sprintf_append(Move(name), fmt,
+ name = JS_sprintf_append(std::move(name), fmt,
to->GetInterface()->GetNameString());
} else if (!name) {
XPCNativeSet* set = GetSet();
XPCNativeInterface** array = set->GetInterfaceArray();
RefPtr<XPCNativeInterface> isupp = XPCNativeInterface::GetISupports();
uint16_t count = set->GetInterfaceCount();
if (count == 1)
- name = JS_sprintf_append(Move(name), "%s", array[0]->GetNameString());
+ name = JS_sprintf_append(std::move(name), "%s", array[0]->GetNameString());
else if (count == 2 && array[0] == isupp) {
- name = JS_sprintf_append(Move(name), "%s", array[1]->GetNameString());
+ name = JS_sprintf_append(std::move(name), "%s", array[1]->GetNameString());
} else {
for (uint16_t i = 0; i < count; i++) {
const char* fmt = (i == 0) ?
"(%s" : (i == count-1) ?
", %s)" : ", %s";
- name = JS_sprintf_append(Move(name), fmt,
+ name = JS_sprintf_append(std::move(name), fmt,
array[i]->GetNameString());
}
}
}
if (!name) {
return nullptr;
}
--- a/js/xpconnect/src/XPCWrappedNativeInfo.cpp
+++ b/js/xpconnect/src/XPCWrappedNativeInfo.cpp
@@ -555,17 +555,17 @@ XPCNativeSet::GetNewOrUsed(nsIClassInfo*
// XXX warn here
continue;
}
interfaceArray.AppendElement(iface.forget());
}
if (interfaceArray.Length() > 0) {
- set = NewInstance(Move(interfaceArray));
+ set = NewInstance(std::move(interfaceArray));
if (set) {
NativeSetMap* map2 = xpcrt->GetNativeSetMap();
if (!map2)
goto out;
XPCNativeSetKey key(set);
XPCNativeSet* set2 = map2->Add(&key, set);
--- a/layout/base/ArenaRefPtr.h
+++ b/layout/base/ArenaRefPtr.h
@@ -142,17 +142,17 @@ private:
if (aPtr == mPtr) {
return;
}
bool sameArena = mPtr && aPtr && mPtr->Arena() == aPtr->Arena();
if (mPtr && !sameArena) {
MOZ_ASSERT(mPtr->Arena());
mPtr->Arena()->DeregisterArenaRefPtr(this);
}
- mPtr = Move(aPtr);
+ mPtr = std::move(aPtr);
if (mPtr && !sameArena) {
MOZ_ASSERT(mPtr->Arena());
mPtr->Arena()->RegisterArenaRefPtr(this);
}
}
RefPtr<T> mPtr;
};
--- a/layout/base/AutoProfilerStyleMarker.h
+++ b/layout/base/AutoProfilerStyleMarker.h
@@ -16,17 +16,17 @@
namespace mozilla {
class MOZ_RAII AutoProfilerStyleMarker
{
public:
explicit AutoProfilerStyleMarker(UniqueProfilerBacktrace aCause)
: mActive(profiler_is_active())
, mStartTime(TimeStamp::Now())
- , mCause(Move(aCause))
+ , mCause(std::move(aCause))
{
if (!mActive) {
return;
}
MOZ_ASSERT(!ServoTraversalStatistics::sActive,
"Nested AutoProfilerStyleMarker");
ServoTraversalStatistics::sSingleton = ServoTraversalStatistics();
ServoTraversalStatistics::sActive = true;
@@ -34,17 +34,17 @@ public:
~AutoProfilerStyleMarker()
{
if (!mActive) {
return;
}
ServoTraversalStatistics::sActive = false;
profiler_add_marker("Styles", MakeUnique<StyleMarkerPayload>(
- mStartTime, TimeStamp::Now(), Move(mCause),
+ mStartTime, TimeStamp::Now(), std::move(mCause),
ServoTraversalStatistics::sSingleton));
}
private:
bool mActive;
TimeStamp mStartTime;
UniqueProfilerBacktrace mCause;
};
--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -937,17 +937,17 @@ PresShell::Init(nsIDocument* aDocument,
// Bind the context to the presentation shell.
mPresContext = aPresContext;
mPresContext->AttachShell(this);
// Now we can initialize the style set. Make sure to set the member before
// calling Init, since various subroutines need to find the style set off
// the PresContext during initialization.
- mStyleSet = Move(aStyleSet);
+ mStyleSet = std::move(aStyleSet);
mStyleSet->Init(aPresContext);
// Notify our prescontext that it now has a compatibility mode. Note that
// this MUST happen after we set up our style set but before we create any
// frames.
mPresContext->CompatibilityModeChanged();
// Add the preference style sheet.
@@ -4274,17 +4274,17 @@ PresShell::DoFlushPendingNotifications(m
if (aFlush.mFlushAnimations && mPresContext->EffectCompositor()) {
mPresContext->EffectCompositor()->PostRestyleForThrottledAnimations();
}
// The FlushResampleRequests() above flushed style changes.
if (!mIsDestroying) {
nsAutoScriptBlocker scriptBlocker;
#ifdef MOZ_GECKO_PROFILER
- AutoProfilerStyleMarker tracingStyleFlush(Move(mStyleCause));
+ AutoProfilerStyleMarker tracingStyleFlush(std::move(mStyleCause));
#endif
mPresContext->RestyleManager()->ProcessPendingRestyles();
}
}
// Process whatever XBL constructors those restyles queued up. This
// ensures that onload doesn't fire too early and that we won't do extra
@@ -4298,17 +4298,17 @@ PresShell::DoFlushPendingNotifications(m
// In particular, reflow depends on style being completely up to
// date. If it's not, then style reparenting, which can
// happen during reflow, might suddenly pick up the new rules and
// we'll end up with frames whose style doesn't match the frame
// type.
if (!mIsDestroying) {
nsAutoScriptBlocker scriptBlocker;
#ifdef MOZ_GECKO_PROFILER
- AutoProfilerStyleMarker tracingStyleFlush(Move(mStyleCause));
+ AutoProfilerStyleMarker tracingStyleFlush(std::move(mStyleCause));
#endif
mPresContext->RestyleManager()->ProcessPendingRestyles();
// Clear mNeedStyleFlush here agagin to make this flag work properly for
// optimization since the flag might have set in ProcessPendingRestyles().
mNeedStyleFlush = false;
}
@@ -4321,17 +4321,17 @@ PresShell::DoFlushPendingNotifications(m
// be good.
if (flushType >= (SuppressInterruptibleReflows()
? FlushType::Layout
: FlushType::InterruptibleLayout) &&
!mIsDestroying) {
#ifdef MOZ_GECKO_PROFILER
AutoProfilerTracing tracingLayoutFlush("Paint", "Reflow",
- Move(mReflowCause));
+ std::move(mReflowCause));
mReflowCause = nullptr;
#endif
didLayoutFlush = true;
mFrameConstructor->RecalcQuotesAndCounters();
viewManager->FlushDelayedResize(true);
if (ProcessReflowCommands(flushType < FlushType::Layout) &&
mContentToScrollTo) {
// We didn't get interrupted. Go ahead and scroll to our content
@@ -5120,17 +5120,17 @@ PresShell::RenderNode(nsINode* aNode,
RefPtr<nsRange> range = new nsRange(aNode);
IgnoredErrorResult rv;
range->SelectNode(*aNode, rv);
if (rv.Failed()) {
return nullptr;
}
UniquePtr<RangePaintInfo> info = CreateRangePaintInfo(range, area, false);
- if (info && !rangeItems.AppendElement(Move(info))) {
+ if (info && !rangeItems.AppendElement(std::move(info))) {
return nullptr;
}
if (aRegion) {
// combine the area with the supplied region
nsIntRect rrectPixels = aRegion->GetBounds();
nsRect rrect = ToAppUnits(rrectPixels, nsPresContext::AppUnitsPerCSSPixel());
@@ -5166,17 +5166,17 @@ PresShell::RenderSelection(Selection* aS
uint32_t numRanges = aSelection->RangeCount();
NS_ASSERTION(numRanges > 0, "RenderSelection called with no selection");
for (uint32_t r = 0; r < numRanges; r++)
{
RefPtr<nsRange> range = aSelection->GetRangeAt(r);
UniquePtr<RangePaintInfo> info = CreateRangePaintInfo(range, area, true);
- if (info && !rangeItems.AppendElement(Move(info))) {
+ if (info && !rangeItems.AppendElement(std::move(info))) {
return nullptr;
}
}
return PaintRangePaintInfo(rangeItems, aSelection, nullptr, area, aPoint,
aScreenRect, aFlags);
}
@@ -5510,17 +5510,17 @@ void PresShell::SynthesizeMouseMove(bool
new nsSynthMouseMoveEvent(this, aFromScroll);
if (!GetPresContext()->RefreshDriver()
->AddRefreshObserver(ev, FlushType::Display)) {
NS_WARNING("failed to dispatch nsSynthMouseMoveEvent");
return;
}
- mSynthMouseMoveEvent = Move(ev);
+ mSynthMouseMoveEvent = std::move(ev);
}
}
/**
* Find the first floating view with a widget in a postorder traversal of the
* view tree that contains the point. Thus more deeply nested floating views
* are preferred over their ancestors, and floating views earlier in the
* view hierarchy (i.e., added later) are preferred over their siblings.
@@ -6063,17 +6063,17 @@ PresShell::ScheduleApproximateFrameVisib
RefPtr<nsRunnableMethod<PresShell>> event =
NewRunnableMethod("PresShell::UpdateApproximateFrameVisibility",
this,
&PresShell::UpdateApproximateFrameVisibility);
nsresult rv =
mDocument->Dispatch(TaskCategory::Other, do_AddRef(event));
if (NS_SUCCEEDED(rv)) {
- mUpdateApproximateFrameVisibilityEvent = Move(event);
+ mUpdateApproximateFrameVisibilityEvent = std::move(event);
}
}
void
PresShell::EnsureFrameInApproximatelyVisibleList(nsIFrame* aFrame)
{
if (!aFrame->TrackingVisibility()) {
return;
@@ -6248,17 +6248,17 @@ PresShell::Paint(nsView* aViewTo
bool computeInvalidRect = computeInvalidFunc ||
(layerManager->GetBackendType() == LayersBackend::LAYERS_BASIC);
UniquePtr<LayerProperties> props;
// For WR, the layermanager has no root layer. We want to avoid
// calling ComputeDifferences in that case because it assumes non-null
// and crashes.
if (computeInvalidRect && layerManager->GetRoot()) {
- props = Move(LayerProperties::CloneFrom(layerManager->GetRoot()));
+ props = std::move(LayerProperties::CloneFrom(layerManager->GetRoot()));
}
MaybeSetupTransactionIdAllocator(layerManager, presContext);
if (layerManager->EndEmptyTransaction((aFlags & PAINT_COMPOSITE) ?
LayerManager::END_DEFAULT : LayerManager::END_NO_COMPOSITE)) {
nsIntRegion invalid;
bool areaOverflowed = false;
@@ -9750,17 +9750,17 @@ PresShell::VerifyIncrementalReflow()
// Make the new presentation context the same size as our
// presentation context.
cx->SetVisibleArea(mPresContext->GetVisibleArea());
// Create a new presentation shell to view the document. Use the
// exact same style information that this document has.
UniquePtr<ServoStyleSet> newSet = CloneStyleSet(StyleSet());
- nsCOMPtr<nsIPresShell> sh = mDocument->CreateShell(cx, vm, Move(newSet));
+ nsCOMPtr<nsIPresShell> sh = mDocument->CreateShell(cx, vm, std::move(newSet));
NS_ENSURE_TRUE(sh, false);
// Note that after we create the shell, we must make sure to destroy it
sh->SetVerifyReflowEnable(false); // turn off verify reflow while we're reflowing the test frame tree
vm->SetPresShell(sh);
{
nsAutoCauseReflowNotifier crNotifier(this);
sh->Initialize();
}
--- a/layout/base/gtest/TestAccessibleCaretEventHub.cpp
+++ b/layout/base/gtest/TestAccessibleCaretEventHub.cpp
@@ -122,17 +122,17 @@ public:
nscoord aY)
{
auto event = MakeUnique<WidgetMouseEvent>(true, aMessage, nullptr,
WidgetMouseEvent::eReal);
event->button = WidgetMouseEvent::eLeftButton;
event->mRefPoint = LayoutDeviceIntPoint(aX, aY);
- return Move(event);
+ return std::move(event);
}
static UniquePtr<WidgetEvent> CreateMousePressEvent(nscoord aX, nscoord aY)
{
return CreateMouseEvent(eMouseDown, aX, aY);
}
static UniquePtr<WidgetEvent> CreateMouseMoveEvent(nscoord aX, nscoord aY)
@@ -160,17 +160,17 @@ public:
LayoutDeviceIntPoint radius(19, 19);
float rotationAngle = 0;
float force = 1;
RefPtr<dom::Touch> touch(
new dom::Touch(identifier, point, radius, rotationAngle, force));
event->mTouches.AppendElement(touch);
- return Move(event);
+ return std::move(event);
}
static UniquePtr<WidgetEvent> CreateTouchStartEvent(nscoord aX, nscoord aY)
{
return CreateTouchEvent(eTouchStart, aX, aY);
}
static UniquePtr<WidgetEvent> CreateTouchMoveEvent(nscoord aX, nscoord aY)
@@ -187,17 +187,17 @@ public:
{
return CreateTouchEvent(eTouchCancel, aX, aY);
}
static UniquePtr<WidgetEvent> CreateWheelEvent(EventMessage aMessage)
{
auto event = MakeUnique<WidgetWheelEvent>(true, aMessage, nullptr);
- return Move(event);
+ return std::move(event);
}
MOZ_CAN_RUN_SCRIPT_BOUNDARY void TestAsyncPanZoomScroll();
MOZ_CAN_RUN_SCRIPT_BOUNDARY
void HandleEventAndCheckState(UniquePtr<WidgetEvent> aEvent,
MockAccessibleCaretEventHub::State* aExpectedState,
nsEventStatus aExpectedEventStatus)
--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -12174,17 +12174,17 @@ Iterator::AppendItemsToList(nsCSSFrameCo
if (!AtStart() || !aEnd.IsDone() || !aTargetList.IsEmpty()) {
do {
AppendItemToList(aTargetList);
} while (*this != aEnd);
return;
}
// Move our entire list of items into the empty target list.
- aTargetList.mItems = Move(mList.mItems);
+ aTargetList.mItems = std::move(mList.mItems);
// Copy over the various counters
aTargetList.mInlineCount = mList.mInlineCount;
aTargetList.mBlockCount = mList.mBlockCount;
aTargetList.mLineParticipantCount = mList.mLineParticipantCount;
aTargetList.mItemCount = mList.mItemCount;
memcpy(aTargetList.mDesiredParentCounts, mList.mDesiredParentCounts,
sizeof(aTargetList.mDesiredParentCounts));
--- a/layout/base/nsDocumentViewer.cpp
+++ b/layout/base/nsDocumentViewer.cpp
@@ -787,17 +787,17 @@ nsDocumentViewer::InitPresentationStuff(
NS_ASSERTION(!mPresShell,
"Someone should have destroyed the presshell!");
// Create the style set...
UniquePtr<ServoStyleSet> styleSet = CreateStyleSet(mDocument);
// Now make the shell for the document
mPresShell = mDocument->CreateShell(mPresContext, mViewManager,
- mozilla::Move(styleSet));
+ std::move(styleSet));
if (!mPresShell) {
return NS_ERROR_FAILURE;
}
if (aDoInitialReflow) {
// Since Initialize() will create frames for *all* items
// that are currently in the document tree, we need to flush
// any pending notifications to prevent the content sink from
@@ -1899,17 +1899,17 @@ nsDocumentViewer::Destroy()
// All callers are supposed to call destroy to break circular
// references. If we do this stuff in the destructor, the
// destructor might never be called (especially if we're being
// used from JS.
#ifdef NS_PRINTING
if (mPrintJob) {
- RefPtr<nsPrintJob> printJob = mozilla::Move(mPrintJob);
+ RefPtr<nsPrintJob> printJob = std::move(mPrintJob);
#ifdef NS_PRINT_PREVIEW
bool doingPrintPreview;
printJob->GetDoingPrintPreview(&doingPrintPreview);
if (doingPrintPreview) {
printJob->FinishPrintPreview();
}
#endif
printJob->Destroy();
--- a/layout/base/nsFrameManager.cpp
+++ b/layout/base/nsFrameManager.cpp
@@ -158,17 +158,17 @@ nsFrameManager::CaptureFrameStateFor(nsI
nsIContent* content = aFrame->GetContent();
nsIDocument* doc = content ? content->GetUncomposedDoc() : nullptr;
nsresult rv = statefulFrame->GenerateStateKey(content, doc, stateKey);
if(NS_FAILED(rv) || stateKey.IsEmpty()) {
return;
}
// Store the state. aState owns frameState now.
- aState->AddState(stateKey, Move(frameState));
+ aState->AddState(stateKey, std::move(frameState));
}
void
nsFrameManager::CaptureFrameState(nsIFrame* aFrame,
nsILayoutHistoryState* aState)
{
MOZ_ASSERT(nullptr != aFrame && nullptr != aState, "null parameters passed in");
--- a/layout/base/nsLayoutHistoryState.cpp
+++ b/layout/base/nsLayoutHistoryState.cpp
@@ -104,25 +104,25 @@ nsLayoutHistoryState::AddNewPresState(co
float aRes, bool aScaleToRes)
{
UniquePtr<PresState> newState = NewPresState();
newState->scrollState() = nsPoint(aScrollX, aScrollY);
newState->allowScrollOriginDowngrade() = aAllowScrollOriginDowngrade;
newState->resolution() = aRes;
newState->scaleToResolution() = aScaleToRes;
- mStates.Put(nsCString(aKey), Move(newState));
+ mStates.Put(nsCString(aKey), std::move(newState));
return NS_OK;
}
void
nsLayoutHistoryState::AddState(const nsCString& aStateKey, UniquePtr<PresState> aState)
{
- mStates.Put(aStateKey, Move(aState));
+ mStates.Put(aStateKey, std::move(aState));
}
PresState*
nsLayoutHistoryState::GetState(const nsCString& aKey)
{
UniquePtr<PresState>* statePtr = mStates.GetValue(aKey);
if (!statePtr) {
return nullptr;
--- a/layout/base/nsRefreshDriver.cpp
+++ b/layout/base/nsRefreshDriver.cpp
@@ -1576,17 +1576,17 @@ TakeFrameRequestCallbacksFrom(nsIDocumen
aTarget.AppendElement(aDocument);
aDocument->TakeFrameRequestCallbacks(aTarget.LastElement().mCallbacks);
}
void
nsRefreshDriver::DispatchPendingEvents()
{
// Swap out the current pending events
- nsTArray<PendingEvent> pendingEvents(Move(mPendingEvents));
+ nsTArray<PendingEvent> pendingEvents(std::move(mPendingEvents));
for (PendingEvent& event : pendingEvents) {
event.mTarget->DispatchEvent(*event.mEvent);
}
}
void
nsRefreshDriver::UpdateIntersectionObservations()
{
--- a/layout/forms/nsTextControlFrame.cpp
+++ b/layout/forms/nsTextControlFrame.cpp
@@ -784,17 +784,17 @@ void nsTextControlFrame::SetFocus(bool a
fm->GetLastFocusMethod(doc->GetWindow(), &lastFocusMethod);
}
}
if (!(lastFocusMethod & nsIFocusManager::FLAG_BYMOUSE)) {
RefPtr<ScrollOnFocusEvent> event = new ScrollOnFocusEvent(this);
nsresult rv = mContent->OwnerDoc()->Dispatch(TaskCategory::Other,
do_AddRef(event));
if (NS_SUCCEEDED(rv)) {
- mScrollEvent = Move(event);
+ mScrollEvent = std::move(event);
}
}
}
// tell the caret to use our selection
caret->SetSelection(ourSel);
// mutual-exclusion: the selection is either controlled by the
--- a/layout/generic/MathMLTextRunFactory.cpp
+++ b/layout/generic/MathMLTextRunFactory.cpp
@@ -759,17 +759,17 @@ MathMLTextRunFactory::RebuildTextRun(nsT
// will be incorrect, but not significantly so.
newFontGroup = fontGroup;
}
if (mInnerTransformingTextRunFactory) {
transformedChild = mInnerTransformingTextRunFactory->MakeTextRun(
convertedString.BeginReading(), convertedString.Length(),
&innerParams, newFontGroup, flags, nsTextFrameUtils::Flags(),
- Move(styleArray), false);
+ std::move(styleArray), false);
child = transformedChild.get();
} else {
cachedChild = newFontGroup->MakeTextRun(
convertedString.BeginReading(), convertedString.Length(),
&innerParams, flags, nsTextFrameUtils::Flags(), aMFR);
child = cachedChild.get();
}
if (!child)
--- a/layout/generic/MathMLTextRunFactory.h
+++ b/layout/generic/MathMLTextRunFactory.h
@@ -13,17 +13,17 @@
/**
* Builds textruns that render their text with MathML specific renderings.
*/
class MathMLTextRunFactory : public nsTransformingTextRunFactory {
public:
MathMLTextRunFactory(mozilla::UniquePtr<nsTransformingTextRunFactory> aInnerTransformingTextRunFactory,
uint32_t aFlags, uint8_t aSSTYScriptLevel,
float aFontInflation)
- : mInnerTransformingTextRunFactory(Move(aInnerTransformingTextRunFactory)),
+ : mInnerTransformingTextRunFactory(std::move(aInnerTransformingTextRunFactory)),
mFlags(aFlags),
mFontInflation(aFontInflation),
mSSTYScriptLevel(aSSTYScriptLevel) {}
virtual void RebuildTextRun(nsTransformedTextRun* aTextRun,
mozilla::gfx::DrawTarget* aRefDrawTarget,
gfxMissingFontRecorder* aMFR) override;
enum {
--- a/layout/generic/nsBulletFrame.cpp
+++ b/layout/generic/nsBulletFrame.cpp
@@ -139,17 +139,17 @@ nsBulletFrame::DidSetComputedStyle(Compu
getter_AddRefs(newRequestClone));
// Deregister the old request. We wait until after Clone is done in case
// the old request and the new request are the same underlying image
// accessed via different URLs.
DeregisterAndCancelImageRequest();
// Register the new request.
- mImageRequest = Move(newRequestClone);
+ mImageRequest = std::move(newRequestClone);
RegisterImageRequest(/* aKnownToBeAnimated = */ false);
}
} else {
// No image request on the new ComputedStyle.
DeregisterAndCancelImageRequest();
}
#ifdef ACCESSIBILITY
--- a/layout/generic/nsFloatManager.cpp
+++ b/layout/generic/nsFloatManager.cpp
@@ -273,17 +273,17 @@ nsFloatManager::AddFloat(nsIFrame* aFloa
MOZ_ASSERT(floatStyle == StyleFloat::Left || floatStyle == StyleFloat::Right,
"Unexpected float style!");
nscoord& sideBEnd =
floatStyle == StyleFloat::Left ? info.mLeftBEnd : info.mRightBEnd;
nscoord thisBEnd = info.BEnd();
if (thisBEnd > sideBEnd)
sideBEnd = thisBEnd;
- mFloats.AppendElement(Move(info));
+ mFloats.AppendElement(std::move(info));
}
// static
LogicalRect
nsFloatManager::CalculateRegionFor(WritingMode aWM,
nsIFrame* aFloat,
const LogicalMargin& aMargin,
const nsSize& aContainerSize)
@@ -1053,17 +1053,17 @@ nsFloatManager::EllipseShapeInfo::LineRi
// Implements shape-outside: <shape-box> and shape-outside: inset().
//
class nsFloatManager::RoundedBoxShapeInfo final : public nsFloatManager::ShapeInfo
{
public:
RoundedBoxShapeInfo(const nsRect& aRect,
UniquePtr<nscoord[]> aRadii)
: mRect(aRect)
- , mRadii(Move(aRadii))
+ , mRadii(std::move(aRadii))
, mShapeMargin(0)
{}
RoundedBoxShapeInfo(const nsRect& aRect,
UniquePtr<nscoord[]> aRadii,
nscoord aShapeMargin,
int32_t aAppUnitsPerDevPixel);
@@ -1123,17 +1123,17 @@ private:
UniquePtr<EllipseShapeInfo> mLogicalBottomRightCorner;
};
nsFloatManager::RoundedBoxShapeInfo::RoundedBoxShapeInfo(const nsRect& aRect,
UniquePtr<nscoord[]> aRadii,
nscoord aShapeMargin,
int32_t aAppUnitsPerDevPixel)
: mRect(aRect)
- , mRadii(Move(aRadii))
+ , mRadii(std::move(aRadii))
, mShapeMargin(aShapeMargin)
{
MOZ_ASSERT(mShapeMargin > 0 && !EachCornerHasBalancedRadii(mRadii.get()),
"Slow constructor should only be used for for shape-margin > 0 "
"and radii with elliptical corners.");
// Before we inflate mRect by mShapeMargin, construct each of our corners.
// If we do it in this order, it's a bit simpler to calculate the center
@@ -2409,21 +2409,21 @@ nsFloatManager::FloatInfo::FloatInfo(nsI
"All shape-outside values except none should have mShapeInfo!");
// Translate the shape to the same origin as nsFloatManager.
mShapeInfo->Translate(aLineLeft, aBlockStart);
}
#ifdef NS_BUILD_REFCNT_LOGGING
nsFloatManager::FloatInfo::FloatInfo(FloatInfo&& aOther)
- : mFrame(Move(aOther.mFrame))
- , mLeftBEnd(Move(aOther.mLeftBEnd))
- , mRightBEnd(Move(aOther.mRightBEnd))
- , mRect(Move(aOther.mRect))
- , mShapeInfo(Move(aOther.mShapeInfo))
+ : mFrame(std::move(aOther.mFrame))
+ , mLeftBEnd(std::move(aOther.mLeftBEnd))
+ , mRightBEnd(std::move(aOther.mRightBEnd))
+ , mRect(std::move(aOther.mRect))
+ , mShapeInfo(std::move(aOther.mShapeInfo))
{
MOZ_COUNT_CTOR(nsFloatManager::FloatInfo);
}
nsFloatManager::FloatInfo::~FloatInfo()
{
MOZ_COUNT_DTOR(nsFloatManager::FloatInfo);
}
@@ -2644,17 +2644,17 @@ nsFloatManager::ShapeInfo::CreateInset(
// corners.
if (!hasRadii) {
logicalInsetRect.Inflate(aShapeMargin);
auto logicalRadii = MakeUnique<nscoord[]>(8);
for (int32_t i = 0; i < 8; ++i) {
logicalRadii[i] = aShapeMargin;
}
return MakeUnique<RoundedBoxShapeInfo>(logicalInsetRect,
- Move(logicalRadii));
+ std::move(logicalRadii));
}
// If we have radii, and they have balanced/equal corners, we can inflate
// both logicalInsetRect and all the radii and use the fast constructor.
if (RoundedBoxShapeInfo::EachCornerHasBalancedRadii(physicalRadii)) {
logicalInsetRect.Inflate(aShapeMargin);
for (nscoord& r : physicalRadii) {
r += aShapeMargin;
@@ -2750,25 +2750,25 @@ nsFloatManager::ShapeInfo::CreatePolygon
ShapeUtils::ComputePolygonVertices(aBasicShape, physicalShapeBoxRect);
// Convert all the physical vertices to logical.
for (nsPoint& vertex : vertices) {
vertex = ConvertToFloatLogical(vertex, aWM, aContainerSize);
}
if (aShapeMargin == 0) {
- return MakeUnique<PolygonShapeInfo>(Move(vertices));
+ return MakeUnique<PolygonShapeInfo>(std::move(vertices));
}
nsRect marginRect = ConvertToFloatLogical(aMarginRect, aWM, aContainerSize);
// We have to use the full constructor for PolygonShapeInfo. This
// computes the float area using a rasterization method.
int32_t appUnitsPerDevPixel = aFrame->PresContext()->AppUnitsPerDevPixel();
- return MakeUnique<PolygonShapeInfo>(Move(vertices), aShapeMargin,
+ return MakeUnique<PolygonShapeInfo>(std::move(vertices), aShapeMargin,
appUnitsPerDevPixel, marginRect);
}
/* static */ UniquePtr<nsFloatManager::ShapeInfo>
nsFloatManager::ShapeInfo::CreateImageShape(
const UniquePtr<nsStyleImage>& aShapeImage,
float aShapeImageThreshold,
nscoord aShapeMargin,
--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -5496,17 +5496,17 @@ nsIFrame::InlinePrefISizeData::ForceBrea
StyleClear floatBreakType = floatDisp->PhysicalBreakType(wm);
if (floatBreakType != aBreakType &&
floatBreakType != StyleClear::None) {
break;
}
}
}
newFloats.Reverse();
- mFloats = Move(newFloats);
+ mFloats = std::move(newFloats);
}
}
mCurrentLine =
NSCoordSaturatingSubtract(mCurrentLine, mTrailingWhitespace, nscoord_MAX);
mPrevLines = std::max(mPrevLines, mCurrentLine);
mCurrentLine = mTrailingWhitespace = 0;
mSkipWhitespace = true;
--- a/layout/generic/nsFrameSelection.cpp
+++ b/layout/generic/nsFrameSelection.cpp
@@ -1459,17 +1459,17 @@ nsFrameSelection::LookUpSelection(nsICon
if (!aContent || !mShell)
return nullptr;
UniquePtr<SelectionDetails> details;
for (size_t j = 0; j < ArrayLength(mDomSelections); j++) {
if (mDomSelections[j]) {
details = mDomSelections[j]->LookUpSelection(aContent, aContentOffset,
- aContentLength, Move(details),
+ aContentLength, std::move(details),
kPresentSelectionTypes[j],
aSlowCheck);
}
}
return details;
}
--- a/layout/generic/nsGridContainerFrame.cpp
+++ b/layout/generic/nsGridContainerFrame.cpp
@@ -4612,17 +4612,17 @@ nsGridContainerFrame::Tracks::StretchFle
aAvailableSize = maxSize;
} else if (newSize < minSize) {
aAvailableSize = minSize;
}
if (aAvailableSize != NS_UNCONSTRAINEDSIZE) {
aAvailableSize = std::max(0, aAvailableSize - sumOfGridGaps);
// Restart with the original track sizes and definite aAvailableSize.
if (origSizes.isSome()) {
- mSizes = Move(*origSizes);
+ mSizes = std::move(*origSizes);
origSizes.reset();
} // else, no mSizes[].mBase were changed above so it's still correct
if (aAvailableSize == 0) {
break; // zero available size wouldn't change any sizes though...
}
continue;
}
}
@@ -6123,20 +6123,20 @@ nsGridContainerFrame::Reflow(nsPresConte
col++;
}
ComputedGridTrackInfo* colInfo = new ComputedGridTrackInfo(
gridReflowInput.mColFunctions.mExplicitGridOffset,
gridReflowInput.mColFunctions.NumExplicitTracks(),
0,
col,
- Move(colTrackPositions),
- Move(colTrackSizes),
- Move(colTrackStates),
- Move(colRemovedRepeatTracks),
+ std::move(colTrackPositions),
+ std::move(colTrackSizes),
+ std::move(colTrackStates),
+ std::move(colRemovedRepeatTracks),
gridReflowInput.mColFunctions.mRepeatAutoStart);
SetProperty(GridColTrackInfo(), colInfo);
uint32_t rowTrackCount = gridReflowInput.mRows.mSizes.Length();
nsTArray<nscoord> rowTrackPositions(rowTrackCount);
nsTArray<nscoord> rowTrackSizes(rowTrackCount);
nsTArray<uint32_t> rowTrackStates(rowTrackCount);
nsTArray<bool> rowRemovedRepeatTracks(
@@ -6158,20 +6158,20 @@ nsGridContainerFrame::Reflow(nsPresConte
// Row info has to accomodate fragmentation of the grid, which may happen in
// later calls to Reflow. For now, presume that no more fragmentation will
// occur.
ComputedGridTrackInfo* rowInfo = new ComputedGridTrackInfo(
gridReflowInput.mRowFunctions.mExplicitGridOffset,
gridReflowInput.mRowFunctions.NumExplicitTracks(),
gridReflowInput.mStartRow,
row,
- Move(rowTrackPositions),
- Move(rowTrackSizes),
- Move(rowTrackStates),
- Move(rowRemovedRepeatTracks),
+ std::move(rowTrackPositions),
+ std::move(rowTrackSizes),
+ std::move(rowTrackStates),
+ std::move(rowRemovedRepeatTracks),
gridReflowInput.mRowFunctions.mRepeatAutoStart);
SetProperty(GridRowTrackInfo(), rowInfo);
if (prevInFlow) {
// This frame is fragmenting rows from a previous frame, so patch up
// the prior GridRowTrackInfo with a new end row.
// FIXME: This can be streamlined and/or removed when bug 1151204 lands.
@@ -6189,20 +6189,20 @@ nsGridContainerFrame::Reflow(nsPresConte
}
}
ComputedGridTrackInfo* revisedPriorRowInfo = new ComputedGridTrackInfo(
priorRowInfo->mNumLeadingImplicitTracks,
priorRowInfo->mNumExplicitTracks,
priorRowInfo->mStartFragmentTrack,
gridReflowInput.mStartRow,
- Move(priorRowInfo->mPositions),
- Move(priorRowInfo->mSizes),
- Move(priorRowInfo->mStates),
- Move(priorRowInfo->mRemovedRepeatTracks),
+ std::move(priorRowInfo->mPositions),
+ std::move(priorRowInfo->mSizes),
+ std::move(priorRowInfo->mStates),
+ std::move(priorRowInfo->mRemovedRepeatTracks),
priorRowInfo->mRepeatFirstTrack);
prevInFlow->SetProperty(GridRowTrackInfo(), revisedPriorRowInfo);
}
// Generate the line info properties. We need to provide the number of
// repeat tracks produced in the reflow. Only explicit names are assigned
// to lines here; the mozilla::dom::GridLines class will later extract
// implicit names from grid areas and assign them to the appropriate lines.
@@ -6229,20 +6229,20 @@ nsGridContainerFrame::Reflow(nsPresConte
// for the first explicit line after the repeat auto declaration.
uint32_t repeatAutoEnd = gridColTemplate.mRepeatAutoIndex + 1;
MOZ_ASSERT(repeatAutoEnd < gridColTemplate.mLineNameLists.Length());
colNamesFollowingRepeat.AppendElements(
gridColTemplate.mLineNameLists[repeatAutoEnd]);
}
ComputedGridLineInfo* columnLineInfo = new ComputedGridLineInfo(
- Move(columnLineNames),
+ std::move(columnLineNames),
gridColTemplate.mRepeatAutoLineNameListBefore,
gridColTemplate.mRepeatAutoLineNameListAfter,
- Move(colNamesFollowingRepeat));
+ std::move(colNamesFollowingRepeat));
SetProperty(GridColumnLineInfo(), columnLineInfo);
// Generate row lines next.
capacity = gridReflowInput.mRows.mSizes.Length();
const nsStyleGridTemplate& gridRowTemplate =
gridReflowInput.mGridStyle->GridTemplateRows();
nsTArray<nsTArray<nsString>> rowLineNames(capacity);
for (row = 0; row <= gridReflowInput.mRows.mSizes.Length(); row++) {
@@ -6262,20 +6262,20 @@ nsGridContainerFrame::Reflow(nsPresConte
// for the first explicit line after the repeat auto declaration.
uint32_t repeatAutoEnd = gridRowTemplate.mRepeatAutoIndex + 1;
MOZ_ASSERT(repeatAutoEnd < gridRowTemplate.mLineNameLists.Length());
rowNamesFollowingRepeat.AppendElements(
gridRowTemplate.mLineNameLists[repeatAutoEnd]);
}
ComputedGridLineInfo* rowLineInfo = new ComputedGridLineInfo(
- Move(rowLineNames),
+ std::move(rowLineNames),
gridRowTemplate.mRepeatAutoLineNameListBefore,
gridRowTemplate.mRepeatAutoLineNameListAfter,
- Move(rowNamesFollowingRepeat));
+ std::move(rowNamesFollowingRepeat));
SetProperty(GridRowLineInfo(), rowLineInfo);
// Generate area info for explicit areas. Implicit areas are handled
// elsewhere.
if (gridReflowInput.mGridStyle->mGridTemplateAreas) {
nsTArray<css::GridNamedArea>* areas = new nsTArray<css::GridNamedArea>(
gridReflowInput.mGridStyle->mGridTemplateAreas->mNamedAreas);
SetProperty(ExplicitNamedAreasProperty(), areas);
--- a/layout/generic/nsImageMap.cpp
+++ b/layout/generic/nsImageMap.cpp
@@ -250,17 +250,17 @@ void Area::ParseCoords(const nsAString&
if (ptr)
{
*ptr = ',';
tptr = ptr + 1;
}
}
mNumCoords = cnt;
- mCoords = Move(value_list);
+ mCoords = std::move(value_list);
free(cp);
}
}
void Area::HasFocus(bool aHasFocus)
{
mHasFocus = aHasFocus;
@@ -834,17 +834,17 @@ nsImageMap::AddArea(HTMLAreaElement* aAr
// nsCSSFrameConstructor::ContentRemoved (both hacks there), and
// RestyleManager::ProcessRestyledFrames to work around this issue can
// be removed.
aArea->SetPrimaryFrame(mImageFrame);
nsAutoString coords;
aArea->GetAttr(kNameSpaceID_None, nsGkAtoms::coords, coords);
area->ParseCoords(coords);
- mAreas.AppendElement(Move(area));
+ mAreas.AppendElement(std::move(area));
}
nsIContent*
nsImageMap::GetArea(nscoord aX, nscoord aY) const
{
NS_ASSERTION(mMap, "Not initialized");
for (const auto& area : mAreas) {
if (area->IsInside(aX, aY)) {
@@ -921,17 +921,17 @@ nsImageMap::ContentInserted(nsIContent*
static UniquePtr<Area>
TakeArea(nsImageMap::AreaList& aAreas, HTMLAreaElement* aArea)
{
UniquePtr<Area> result;
size_t index = 0;
for (UniquePtr<Area>& area : aAreas) {
if (area->mArea == aArea) {
- result = Move(area);
+ result = std::move(area);
break;
}
index++;
}
if (result) {
aAreas.RemoveElementAt(index);
}
--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -2323,21 +2323,21 @@ BuildTextRunsScanner::BuildTextRunForFra
nsTextFrameUtils::AppendLineBreakOffset(&textBreakPointsAfterTransform,
transformedLength);
}
// Setup factory chain
UniquePtr<nsTransformingTextRunFactory> transformingFactory;
if (anyTextTransformStyle) {
transformingFactory =
- MakeUnique<nsCaseTransformTextRunFactory>(Move(transformingFactory));
+ MakeUnique<nsCaseTransformTextRunFactory>(std::move(transformingFactory));
}
if (anyMathMLStyling) {
transformingFactory =
- MakeUnique<MathMLTextRunFactory>(Move(transformingFactory), mathFlags,
+ MakeUnique<MathMLTextRunFactory>(std::move(transformingFactory), mathFlags,
sstyScriptLevel, fontInflation);
}
nsTArray<RefPtr<nsTransformedCharStyle>> styles;
if (transformingFactory) {
iter.SetOriginalOffset(0);
for (uint32_t i = 0; i < mMappedFlows.Length(); ++i) {
MappedFlow* mappedFlow = &mMappedFlows[i];
nsTextFrame* f;
@@ -2375,34 +2375,34 @@ BuildTextRunsScanner::BuildTextRunForFra
uint32_t(textBreakPointsAfterTransform.Length()),
int32_t(firstFrame->PresContext()->AppUnitsPerDevPixel())};
if (mDoubleByteText) {
const char16_t* text = static_cast<const char16_t*>(textPtr);
if (transformingFactory) {
textRun = transformingFactory->MakeTextRun(text, transformedLength,
¶ms, fontGroup, flags, flags2,
- Move(styles), true);
+ std::move(styles), true);
if (textRun) {
// ownership of the factory has passed to the textrun
// TODO: bug 1285316: clean up ownership transfer from the factory to
// the textrun
Unused << transformingFactory.release();
}
} else {
textRun = fontGroup->MakeTextRun(text, transformedLength, ¶ms,
flags, flags2, mMissingFonts);
}
} else {
const uint8_t* text = static_cast<const uint8_t*>(textPtr);
flags |= gfx::ShapedTextFlags::TEXT_IS_8BIT;
if (transformingFactory) {
textRun = transformingFactory->MakeTextRun(text, transformedLength,
¶ms, fontGroup, flags, flags2,
- Move(styles), true);
+ std::move(styles), true);
if (textRun) {
// ownership of the factory has passed to the textrun
// TODO: bug 1285316: clean up ownership transfer from the factory to
// the textrun
Unused << transformingFactory.release();
}
} else {
textRun = fontGroup->MakeTextRun(text, transformedLength, ¶ms,
@@ -3374,17 +3374,17 @@ PropertyProvider::ComputeJustification(
// We counted the expansion opportunity after the last character,
// but it is not an inner opportunity.
MOZ_ASSERT(info.mInnerOpportunities > 0);
info.mInnerOpportunities--;
info.mIsEndJustifiable = true;
}
if (aAssignments) {
- *aAssignments = Move(assignments);
+ *aAssignments = std::move(assignments);
}
return info;
}
// aStart, aLength in transformed string offsets
void
PropertyProvider::GetSpacing(Range aRange, Spacing* aSpacing) const
{
--- a/layout/generic/nsTextRunTransformations.cpp
+++ b/layout/generic/nsTextRunTransformations.cpp
@@ -51,17 +51,17 @@ nsTransformedTextRun::Create(const gfxTe
void *storage = AllocateStorageForTextRun(sizeof(nsTransformedTextRun), aLength);
if (!storage) {
return nullptr;
}
RefPtr<nsTransformedTextRun> result =
new (storage) nsTransformedTextRun(aParams, aFactory, aFontGroup,
aString, aLength, aFlags, aFlags2,
- Move(aStyles), aOwnsFactory);
+ std::move(aStyles), aOwnsFactory);
return result.forget();
}
void
nsTransformedTextRun::SetCapitalization(uint32_t aStart, uint32_t aLength,
bool* aCapitalization)
{
if (mCapitalize.IsEmpty()) {
@@ -107,17 +107,17 @@ nsTransformingTextRunFactory::MakeTextRu
const gfxTextRunFactory::Parameters* aParams,
gfxFontGroup* aFontGroup,
gfx::ShapedTextFlags aFlags,
nsTextFrameUtils::Flags aFlags2,
nsTArray<RefPtr<nsTransformedCharStyle>>&& aStyles,
bool aOwnsFactory)
{
return nsTransformedTextRun::Create(aParams, this, aFontGroup,
- aString, aLength, aFlags, aFlags2, Move(aStyles),
+ aString, aLength, aFlags, aFlags2, std::move(aStyles),
aOwnsFactory);
}
already_AddRefed<nsTransformedTextRun>
nsTransformingTextRunFactory::MakeTextRun(const uint8_t* aString, uint32_t aLength,
const gfxTextRunFactory::Parameters* aParams,
gfxFontGroup* aFontGroup,
gfx::ShapedTextFlags aFlags,
@@ -126,17 +126,17 @@ nsTransformingTextRunFactory::MakeTextRu
bool aOwnsFactory)
{
// We'll only have a Unicode code path to minimize the amount of code needed
// for these rarely used features
NS_ConvertASCIItoUTF16 unicodeString(reinterpret_cast<const char*>(aString), aLength);
return MakeTextRun(unicodeString.get(), aLength, aParams, aFontGroup,
aFlags & ~gfx::ShapedTextFlags::TEXT_IS_8BIT,
aFlags2,
- Move(aStyles), aOwnsFactory);
+ std::move(aStyles), aOwnsFactory);
}
void
MergeCharactersInTextRun(gfxTextRun* aDest, gfxTextRun* aSrc,
const bool* aCharsToMerge, const bool* aDeletedChars)
{
aDest->ResetGlyphRuns();
@@ -677,17 +677,17 @@ nsCaseTransformTextRunFactory::RebuildTe
RefPtr<nsTransformedTextRun> transformedChild;
RefPtr<gfxTextRun> cachedChild;
gfxTextRun* child;
if (mInnerTransformingTextRunFactory) {
transformedChild = mInnerTransformingTextRunFactory->MakeTextRun(
convertedString.BeginReading(), convertedString.Length(),
&innerParams, fontGroup, flags, nsTextFrameUtils::Flags(),
- Move(styleArray), false);
+ std::move(styleArray), false);
child = transformedChild.get();
} else {
cachedChild = fontGroup->MakeTextRun(
convertedString.BeginReading(), convertedString.Length(),
&innerParams, flags, nsTextFrameUtils::Flags(), aMFR);
child = cachedChild.get();
}
if (!child)
--- a/layout/generic/nsTextRunTransformations.h
+++ b/layout/generic/nsTextRunTransformations.h
@@ -82,17 +82,17 @@ public:
// factory, no title-case conversion, and no upper-casing of SZLIG, we override
// MakeTextRun (after making it virtual in the superclass) and have it
// just convert the string to uppercase or lowercase and create the textrun
// via the fontgroup.
// Takes ownership of aInnerTransformTextRunFactory
explicit nsCaseTransformTextRunFactory(mozilla::UniquePtr<nsTransformingTextRunFactory> aInnerTransformingTextRunFactory,
bool aAllUppercase = false)
- : mInnerTransformingTextRunFactory(Move(aInnerTransformingTextRunFactory)),
+ : mInnerTransformingTextRunFactory(std::move(aInnerTransformingTextRunFactory)),
mAllUppercase(aAllUppercase) {}
virtual void RebuildTextRun(nsTransformedTextRun* aTextRun,
mozilla::gfx::DrawTarget* aRefDrawTarget,
gfxMissingFontRecorder* aMFR) override;
// Perform a transformation on the given string, writing the result into
// aConvertedString. If aAllUppercase is true, the transform is (global)
--- a/layout/mathml/nsMathMLChar.cpp
+++ b/layout/mathml/nsMathMLChar.cpp
@@ -58,17 +58,17 @@ static const float kIntegralFactor = 2.0
static void
NormalizeDefaultFont(nsFont& aFont, float aFontSizeInflation)
{
if (aFont.fontlist.GetDefaultFontType() != eFamily_none) {
nsTArray<FontFamilyName> names;
names.AppendElements(aFont.fontlist.GetFontlist()->mNames);
names.AppendElement(FontFamilyName(aFont.fontlist.GetDefaultFontType()));
- aFont.fontlist.SetFontlist(Move(names));
+ aFont.fontlist.SetFontlist(std::move(names));
aFont.fontlist.SetDefaultFontType(eFamily_none);
}
aFont.size = NSToCoordRound(aFont.size * aFontSizeInflation);
}
// -----------------------------------------------------------------------------
static const nsGlyphCode kNullGlyph = {{{0, 0}}, 0};
@@ -975,17 +975,17 @@ nsMathMLChar::SetFontFamily(nsPresContex
nsFont& aFont,
RefPtr<gfxFontGroup>* aFontGroup)
{
FontFamilyList glyphCodeFont;
if (aGlyphCode.font) {
nsTArray<FontFamilyName> names;
names.AppendElement(aGlyphTable->FontNameFor(aGlyphCode));
- glyphCodeFont.SetFontlist(Move(names));
+ glyphCodeFont.SetFontlist(std::move(names));
}
const FontFamilyList& familyList =
aGlyphCode.font ? glyphCodeFont : aDefaultFamilyList;
if (!*aFontGroup || !(aFont.fontlist == familyList)) {
nsFont font = aFont;
font.fontlist = familyList;
@@ -1202,17 +1202,17 @@ StretchEnumContext::TryVariants(nsGlyphT
mBoundingMetrics.rightBearing = bm.rightBearing;
// Continue to check other sizes unless largeopOnly
haveBetter = largeopOnly;
}
else {
mBoundingMetrics = bm;
haveBetter = true;
bestSize = charSize;
- mChar->mGlyphs[0] = Move(textRun);
+ mChar->mGlyphs[0] = std::move(textRun);
mChar->mDraw = DRAW_VARIANT;
}
#ifdef NOISY_SEARCH
printf(" size:%d Current best\n", size);
#endif
}
else {
#ifdef NOISY_SEARCH
@@ -1392,17 +1392,17 @@ nsMathMLChar::StretchEnumContext::TryPar
}
mGlyphFound = true;
if (maxWidth)
return false; // Continue to check other sizes
// reset
mChar->mDraw = DRAW_PARTS;
for (int32_t i = 0; i < 4; i++) {
- mChar->mGlyphs[i] = Move(textRun[i]);
+ mChar->mGlyphs[i] = std::move(textRun[i]);
mChar->mBmData[i] = bmdata[i];
}
return IsSizeOK(computedSize, mTargetSize, mStretchHint);
}
// This is called for each family, whether it exists or not
bool
@@ -1497,17 +1497,17 @@ InsertMathFallbacks(FontFamilyList& aFam
AppendFallbacks(mergedList, aFallbacks);
}
mergedList.AppendElement(name);
}
if (!inserted) {
AppendFallbacks(mergedList, aFallbacks);
}
- aFamilyList.SetFontlist(Move(mergedList));
+ aFamilyList.SetFontlist(std::move(mergedList));
}
nsresult
nsMathMLChar::StretchInternal(nsIFrame* aForFrame,
DrawTarget* aDrawTarget,
float aFontSizeInflation,
nsStretchDirection& aStretchDirection,
const nsBoundingMetrics& aContainerSize,
--- a/layout/painting/FrameLayerBuilder.cpp
+++ b/layout/painting/FrameLayerBuilder.cpp
@@ -1824,17 +1824,17 @@ struct CSSMaskLayerUserData : public Lay
mMaskStyle(aFrame->StyleSVGReset()->mMask),
mMaskLayerOffset(aMaskLayerOffset)
{
}
void operator=(CSSMaskLayerUserData&& aOther)
{
mMaskBounds = aOther.mMaskBounds;
- mMaskStyle = Move(aOther.mMaskStyle);
+ mMaskStyle = std::move(aOther.mMaskStyle);
mMaskLayerOffset = aOther.mMaskLayerOffset;
}
bool
operator==(const CSSMaskLayerUserData& aOther) const
{
if (!mMaskBounds.IsEqualInterior(aOther.mMaskBounds)) {
return false;
@@ -2920,17 +2920,17 @@ PaintedLayerDataNode::~PaintedLayerDataN
}
PaintedLayerDataNode*
PaintedLayerDataNode::AddChildNodeFor(AnimatedGeometryRoot* aAnimatedGeometryRoot)
{
MOZ_ASSERT(aAnimatedGeometryRoot->mParentAGR == mAnimatedGeometryRoot);
UniquePtr<PaintedLayerDataNode> child =
MakeUnique<PaintedLayerDataNode>(mTree, this, aAnimatedGeometryRoot);
- mChildren.AppendElement(Move(child));
+ mChildren.AppendElement(std::move(child));
return mChildren.LastElement().get();
}
template<typename NewPaintedLayerCallbackType>
PaintedLayerData*
PaintedLayerDataNode::FindPaintedLayerFor(const nsIntRect& aVisibleRect,
const bool aBackfaceHidden,
const ActiveScrolledRoot* aASR,
@@ -3486,17 +3486,17 @@ void ContainerState::FinishPaintedLayerD
} else if (data->mNeedComponentAlpha && !hidpi) {
flags |= Layer::CONTENT_COMPONENT_ALPHA;
}
if (data->mDisableFlattening) {
flags |= Layer::CONTENT_DISABLE_FLATTENING;
}
layer->SetContentFlags(flags);
- userData->mItems = Move(data->mAssignedDisplayItems);
+ userData->mItems = std::move(data->mAssignedDisplayItems);
userData->mContainerLayerFrame = GetContainerFrame();
PaintedLayerData* containingPaintedLayerData =
mLayerBuilder->GetContainingPaintedLayerData();
// If we're building layers for an inactive layer, the event regions are
// clipped to the inactive layer's clip prior to being combined into the
// event regions of the containing PLD.
// For the dispatch-to-content and maybe-hit regions, rounded corners on
@@ -3636,17 +3636,17 @@ PaintedLayerData::Accumulate(ContainerSt
mItemClip = &aClip;
if (aType == DisplayItemEntryType::POP_OPACITY) {
MOZ_ASSERT(!mOpacityIndices.IsEmpty());
mOpacityIndices.RemoveLastElement();
AssignedDisplayItem item(aItem, aLayerState,
nullptr, aContentRect, aType, hasOpacity);
- mAssignedDisplayItems.AppendElement(Move(item));
+ mAssignedDisplayItems.AppendElement(std::move(item));
return;
}
if (aState->mBuilder->NeedToForceTransparentSurfaceForItem(aItem)) {
mForceTransparentSurface = true;
}
nsRect componentAlphaBounds;
@@ -3675,17 +3675,17 @@ PaintedLayerData::Accumulate(ContainerSt
aItem->HasMergedFrames() ? nullptr : aItem->GetDisplayItemData();
DisplayItemData* oldData =
aState->mLayerBuilder->GetOldLayerForFrame(aItem->Frame(),
aItem->GetPerFrameKey(),
currentData);
AssignedDisplayItem item(aItem, aLayerState,
oldData, aContentRect, aType, hasOpacity);
- mAssignedDisplayItems.AppendElement(Move(item));
+ mAssignedDisplayItems.AppendElement(std::move(item));
if (aType == DisplayItemEntryType::PUSH_OPACITY) {
mOpacityIndices.AppendElement(mAssignedDisplayItems.Length() - 1);
}
if (aItem->MustPaintOnContentSide()) {
mShouldPaintOnContentSide = true;
}
@@ -3779,17 +3779,17 @@ PaintedLayerData::Accumulate(ContainerSt
// a canvas background), so we need to make sure that the first rect
// we see doesn't get discarded.
nsIntRegion tmp;
tmp.Or(mOpaqueRegion, iter.Get());
// Opaque display items in chrome documents whose window is partially
// transparent are always added to the opaque region. This helps ensure
// that we get as much subpixel-AA as possible in the chrome.
if (tmp.GetNumRects() <= 4 || aItem->Frame()->PresContext()->IsChrome()) {
- mOpaqueRegion = Move(tmp);
+ mOpaqueRegion = std::move(tmp);
}
}
}
if (!aState->mParameters.mDisableSubpixelAntialiasingInDescendants &&
!componentAlphaBounds.IsEmpty()) {
nsIntRect componentAlphaRect =
aState->ScaleToOutsidePixels(componentAlphaBounds, false).Intersect(aVisibleRect);
@@ -4256,17 +4256,17 @@ ContainerState::SetupMaskLayerForCSSMask
RefPtr<ImageContainer> imgContainer =
imageData.CreateImageAndImageContainer();
if (!imgContainer) {
return;
}
maskLayer->SetContainer(imgContainer);
if (isPaintFinished) {
- *oldUserData = Move(newUserData);
+ *oldUserData = std::move(newUserData);
}
aLayer->SetMaskLayer(maskLayer);
}
static bool
IsScrollThumbLayer(nsDisplayItem* aItem)
{
return aItem->GetType() == DisplayItemType::TYPE_OWN_LAYER &&
@@ -6227,17 +6227,17 @@ FrameLayerBuilder::RecomputeVisibilityFo
// region since we aren't displaying everything inside the rect.
if (clip.GetRoundedRectCount() == 0) {
nsRegion removed;
removed.Sub(clipped, finalClipped);
nsRegion newVisible;
newVisible.Sub(visible, removed);
// Don't let the visible region get too complex.
if (newVisible.GetNumRects() <= 15) {
- visible = Move(newVisible);
+ visible = std::move(newVisible);
}
}
}
aPreviousRectToDraw = visible.GetBounds();
}
/**
@@ -6613,17 +6613,17 @@ FrameLayerBuilder::DrawPaintedLayer(Pain
FlashPaint(aContext);
}
if (presContext->GetDocShell() && isActiveLayerManager) {
nsDocShell* docShell = static_cast<nsDocShell*>(presContext->GetDocShell());
RefPtr<TimelineConsumers> timelines = TimelineConsumers::Get();
if (timelines && timelines->HasConsumer(docShell)) {
- timelines->AddMarkerForDocShell(docShell, Move(
+ timelines->AddMarkerForDocShell(docShell, std::move(
MakeUnique<LayerTimelineMarker>(aRegionToDraw)));
}
}
if (!aRegionToInvalidate.IsEmpty()) {
aLayer->AddInvalidRect(aRegionToInvalidate.GetBounds());
}
}
@@ -6823,15 +6823,15 @@ ContainerState::CreateMaskLayer(Layer *a
maskLayer->SetContainer(container);
maskTransform.Invert();
Matrix4x4 matrix = Matrix4x4::From2D(maskTransform);
matrix.PreTranslate(mParameters.mOffset.x, mParameters.mOffset.y, 0);
maskLayer->SetBaseTransform(matrix);
// save the details of the clip in user data
- *userData = Move(newData);
+ *userData = std::move(newData);
userData->mImageKey.Reset(lookupKey);
return maskLayer.forget();
}
} // namespace mozilla
--- a/layout/painting/RetainedDisplayListBuilder.cpp
+++ b/layout/painting/RetainedDisplayListBuilder.cpp
@@ -239,17 +239,17 @@ OldItemInfo::AddedMatchToMergedList(Reta
}
void
OldItemInfo::Discard(RetainedDisplayListBuilder* aBuilder,
nsTArray<MergedListIndex>&& aDirectPredecessors)
{
MOZ_ASSERT(!IsUsed());
mUsed = mDiscarded = true;
- mDirectPredecessors = Move(aDirectPredecessors);
+ mDirectPredecessors = std::move(aDirectPredecessors);
if (mItem) {
mItem->Destroy(aBuilder->Builder());
}
mItem = nullptr;
}
bool
OldItemInfo::IsChanged()
@@ -266,18 +266,18 @@ OldItemInfo::IsChanged()
* Each time we add a new item, we resolve all dependencies for it, so that the resulting
* list and DAG are built in topological ordering.
*/
class MergeState {
public:
MergeState(RetainedDisplayListBuilder* aBuilder, RetainedDisplayList& aOldList, uint32_t aOuterKey)
: mBuilder(aBuilder)
, mOldList(&aOldList)
- , mOldItems(Move(aOldList.mOldItems))
- , mOldDAG(Move(*reinterpret_cast<DirectedAcyclicGraph<OldListUnits>*>(&aOldList.mDAG)))
+ , mOldItems(std::move(aOldList.mOldItems))
+ , mOldDAG(std::move(*reinterpret_cast<DirectedAcyclicGraph<OldListUnits>*>(&aOldList.mDAG)))
, mOuterKey(aOuterKey)
, mResultIsModified(false)
{
mMergedDAG.EnsureCapacityFor(mOldDAG);
}
MergedListIndex ProcessItemFromNewList(nsDisplayItem* aNewItem, const Maybe<MergedListIndex>& aPreviousItem) {
OldListIndex oldIndex;
@@ -315,22 +315,22 @@ public:
RetainedDisplayList Finalize() {
for (size_t i = 0; i < mOldDAG.Length(); i++) {
if (mOldItems[i].IsUsed()) {
continue;
}
AutoTArray<MergedListIndex, 2> directPredecessors =
ResolveNodeIndexesOldToMerged(mOldDAG.GetDirectPredecessors(OldListIndex(i)));
- ProcessOldNode(OldListIndex(i), Move(directPredecessors));
+ ProcessOldNode(OldListIndex(i), std::move(directPredecessors));
}
RetainedDisplayList result;
result.AppendToTop(&mMergedItems);
- result.mDAG = Move(mMergedDAG);
+ result.mDAG = std::move(mMergedDAG);
return result;
}
bool HasMatchingItemInOldList(nsDisplayItem* aItem, OldListIndex* aOutIndex)
{
nsIFrame::DisplayItemArray* items = aItem->Frame()->GetProperty(nsIFrame::DisplayItems());
// Look for an item that matches aItem's frame and per-frame-key, but isn't the same item.
for (nsDisplayItem* i : *items) {
@@ -385,17 +385,17 @@ public:
mMergedItems.AppendToTop(aItem);
MergedListIndex newIndex = mMergedDAG.AddNode(aDirectPredecessors, aExtraDirectPredecessor);
return newIndex;
}
void ProcessOldNode(OldListIndex aNode, nsTArray<MergedListIndex>&& aDirectPredecessors) {
nsDisplayItem* item = mOldItems[aNode.val].mItem;
if (mOldItems[aNode.val].IsChanged() || HasModifiedFrame(item)) {
- mOldItems[aNode.val].Discard(mBuilder, Move(aDirectPredecessors));
+ mOldItems[aNode.val].Discard(mBuilder, std::move(aDirectPredecessors));
mResultIsModified = true;
} else {
if (item->GetChildren()) {
Maybe<const ActiveScrolledRoot*> containerASRForChildren;
nsDisplayList empty;
if (mBuilder->MergeDisplayLists(&empty, item->GetChildren(), item->GetChildren(),
containerASRForChildren, item->GetPerFrameKey())) {
mResultIsModified = true;
@@ -439,17 +439,17 @@ public:
// If we've finished processing all the entries in the current set, then pop
// it off the processing stack and process it.
PredecessorStackItem item = mStack.PopLastElement();
AutoTArray<MergedListIndex,2> result =
ResolveNodeIndexesOldToMerged(item.mDirectPredecessors);
if (mStack.IsEmpty()) {
return result;
} else {
- ProcessOldNode(item.mNode, Move(result));
+ ProcessOldNode(item.mNode, std::move(result));
}
} else {
// Grab the current predecessor, push predecessors of that onto the processing
// stack (if it hasn't already been processed), and then advance to the next entry.
OldListIndex currentIndex = mStack.LastElement().GetAndIncrementCurrentPredecessor();
if (!mOldItems[currentIndex.val].IsUsed()) {
mStack.AppendElement(
PredecessorStackItem(currentIndex, mOldDAG.GetDirectPredecessors(currentIndex)));
@@ -509,17 +509,17 @@ RetainedDisplayListBuilder::MergeDisplay
{
MergeState merge(this, *aOldList, aOuterKey);
Maybe<MergedListIndex> previousItemIndex;
while (nsDisplayItem* item = aNewList->RemoveBottom()) {
previousItemIndex = Some(merge.ProcessItemFromNewList(item, previousItemIndex));
}
- *aOutList = Move(merge.Finalize());
+ *aOutList = std::move(merge.Finalize());
aOutContainerASR = merge.mContainerASR;
return merge.mResultIsModified;
}
static void
TakeAndAddModifiedAndFramesWithPropsFromRootFrame(
nsTArray<nsIFrame*>* aModifiedFrames,
nsTArray<nsIFrame*>* aFramesWithProps,
--- a/layout/painting/RetainedDisplayListHelpers.h
+++ b/layout/painting/RetainedDisplayListHelpers.h
@@ -85,24 +85,24 @@ typedef Index<OldListUnits> OldListIndex
typedef Index<MergedListUnits> MergedListIndex;
template <typename T>
class DirectedAcyclicGraph {
public:
DirectedAcyclicGraph() {}
DirectedAcyclicGraph(DirectedAcyclicGraph&& aOther)
- : mNodesInfo(mozilla::Move(aOther.mNodesInfo))
- , mDirectPredecessorList(mozilla::Move(aOther.mDirectPredecessorList))
+ : mNodesInfo(std::move(aOther.mNodesInfo))
+ , mDirectPredecessorList(std::move(aOther.mDirectPredecessorList))
{}
DirectedAcyclicGraph& operator=(DirectedAcyclicGraph&& aOther)
{
- mNodesInfo = mozilla::Move(aOther.mNodesInfo);
- mDirectPredecessorList = mozilla::Move(aOther.mDirectPredecessorList);
+ mNodesInfo = std::move(aOther.mNodesInfo);
+ mDirectPredecessorList = std::move(aOther.mDirectPredecessorList);
return *this;
}
Index<T> AddNode(mozilla::Span<const Index<T>> aDirectPredecessors,
const mozilla::Maybe<Index<T>>& aExtraPredecessor = mozilla::Nothing())
{
size_t index = mNodesInfo.Length();
mNodesInfo.AppendElement(NodeInfo(mDirectPredecessorList.Length(), aDirectPredecessors.Length()));
--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -2729,17 +2729,17 @@ already_AddRefed<LayerManager> nsDisplay
UniquePtr<LayerProperties> props;
bool computeInvalidRect = (computeInvalidFunc ||
(!layerManager->IsCompositingCheap() && layerManager->NeedsWidgetInvalidation())) &&
widgetTransaction;
if (computeInvalidRect) {
- props = Move(LayerProperties::CloneFrom(layerManager->GetRoot()));
+ props = std::move(LayerProperties::CloneFrom(layerManager->GetRoot()));
}
if (doBeginTransaction) {
if (aCtx) {
if (!layerManager->BeginTransactionWithTarget(aCtx)) {
return nullptr;
}
} else {
@@ -2922,17 +2922,17 @@ static void
FlushFramesArray(nsTArray<FramesWithDepth>& aSource, nsTArray<nsIFrame*>* aDest)
{
if (aSource.IsEmpty()) {
return;
}
aSource.Sort();
uint32_t length = aSource.Length();
for (uint32_t i = 0; i < length; i++) {
- aDest->AppendElements(Move(aSource[i].mFrames));
+ aDest->AppendElements(std::move(aSource[i].mFrames));
}
aSource.Clear();
}
void nsDisplayList::HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,
nsDisplayItem::HitTestState* aState,
nsTArray<nsIFrame*> *aOutFrames) const {
nsDisplayItem* item;
--- a/layout/painting/nsDisplayList.h
+++ b/layout/painting/nsDisplayList.h
@@ -3482,29 +3482,29 @@ private:
* order correctly.
*/
class RetainedDisplayList : public nsDisplayList {
public:
RetainedDisplayList() {}
RetainedDisplayList(RetainedDisplayList&& aOther)
{
AppendToTop(&aOther);
- mDAG = mozilla::Move(aOther.mDAG);
+ mDAG = std::move(aOther.mDAG);
}
~RetainedDisplayList()
{
MOZ_ASSERT(mOldItems.IsEmpty(), "Must empty list before destroying");
}
RetainedDisplayList& operator=(RetainedDisplayList&& aOther)
{
MOZ_ASSERT(!Count(), "Can only move into an empty list!");
MOZ_ASSERT(mOldItems.IsEmpty(), "Can only move into an empty list!");
AppendToTop(&aOther);
- mDAG = mozilla::Move(aOther.mDAG);
+ mDAG = std::move(aOther.mDAG);
return *this;
}
void DeleteAll(nsDisplayListBuilder* aBuilder)
{
for (OldItemInfo& i : mOldItems) {
if (i.mItem) {
i.mItem->Destroy(aBuilder);
@@ -6588,17 +6588,17 @@ public:
{
FrameTransformProperties(const nsIFrame* aFrame,
float aAppUnitsPerPixel,
const nsRect* aBoundsOverride);
FrameTransformProperties(RefPtr<const nsCSSValueSharedList>&&
aTransformList,
const Point3D& aToTransformOrigin)
: mFrame(nullptr)
- , mTransformList(mozilla::Move(aTransformList))
+ , mTransformList(std::move(aTransformList))
, mToTransformOrigin(aToTransformOrigin)
{}
const nsIFrame* mFrame;
const RefPtr<const nsCSSValueSharedList> mTransformList;
const Point3D mToTransformOrigin;
};
--- a/layout/printing/nsPrintJob.cpp
+++ b/layout/printing/nsPrintJob.cpp
@@ -657,17 +657,17 @@ nsPrintJob::DoCommonPrint(bool
if (aIsPrintPreview) {
// The WebProgressListener can be QI'ed to nsIPrintingPromptService
// then that means the progress dialog is already being shown.
nsCOMPtr<nsIPrintingPromptService> pps(do_QueryInterface(aWebProgressListener));
mProgressDialogIsShown = pps != nullptr;
if (mIsDoingPrintPreview) {
- mOldPrtPreview = Move(mPrtPreview);
+ mOldPrtPreview = std::move(mPrtPreview);
}
} else {
mProgressDialogIsShown = false;
}
// Grab the new instance with local variable to guarantee that it won't be
// deleted during this method.
mPrt = new nsPrintData(aIsPrintPreview ? nsPrintData::eIsPrintPreview :
@@ -1409,17 +1409,17 @@ nsPrintJob::BuildDocTree(nsIDocShell*
childAsShell->GetContentViewer(getter_AddRefs(viewer));
if (viewer) {
nsCOMPtr<nsIDocument> doc = do_GetInterface(childAsShell);
auto po = MakeUnique<nsPrintObject>();
po->mParent = aPO.get();
nsresult rv = po->Init(childAsShell, doc, aPO->mPrintPreview);
if (NS_FAILED(rv))
NS_NOTREACHED("Init failed?");
- aPO->mKids.AppendElement(Move(po));
+ aPO->mKids.AppendElement(std::move(po));
aDocList->AppendElement(aPO->mKids.LastElement().get());
BuildDocTree(childAsShell, aDocList, aPO->mKids.LastElement());
}
}
}
}
//-------------------------------------------------------
@@ -2348,17 +2348,17 @@ nsPrintJob::ReflowPrintObject(const Uniq
// The SVG document only loads minimal-xul.css, so it doesn't apply other
// styles. We should add ua.css for applying style which related to print.
auto cache = nsLayoutStylesheetCache::Singleton();
styleSet->PrependStyleSheet(SheetType::Agent, cache->UASheet());
}
aPO->mPresShell = aPO->mDocument->CreateShell(aPO->mPresContext,
aPO->mViewManager,
- Move(styleSet));
+ std::move(styleSet));
if (!aPO->mPresShell) {
return NS_ERROR_FAILURE;
}
// If we're printing selection then remove the unselected nodes from our
// cloned document.
int16_t printRangeType = nsIPrintSettings::kRangeAllPages;
printData->mPrintSettings->GetPrintRange(&printRangeType);
@@ -3469,17 +3469,17 @@ nsPrintJob::FinishPrintPreview()
}
printData->OnEndPrinting();
// XXX If mPrt becomes nullptr or different instance here, what should we
// do?
// PrintPreview was built using the mPrt (code reuse)
// then we assign it over
- mPrtPreview = Move(mPrt);
+ mPrtPreview = std::move(mPrt);
#endif // NS_PRINT_PREVIEW
return NS_OK;
}
//-----------------------------------------------------------------
//-- Done: Finishing up or Cleaning up
--- a/layout/style/CounterStyleManager.cpp
+++ b/layout/style/CounterStyleManager.cpp
@@ -1733,17 +1733,17 @@ AnonymousCounterStyle::AnonymousCounterS
{
}
AnonymousCounterStyle::AnonymousCounterStyle(uint8_t aSystem,
nsTArray<nsString> aSymbols)
: CounterStyle(NS_STYLE_LIST_STYLE_CUSTOM)
, mSingleString(false)
, mSystem(aSystem)
- , mSymbols(Move(aSymbols))
+ , mSymbols(std::move(aSymbols))
{
}
/* virtual */ nsAtom*
AnonymousCounterStyle::GetStyleName() const
{
return nullptr;
}
@@ -2131,15 +2131,15 @@ CounterStyleManager::NotifyRuleChanged()
}
}
return changed;
}
void
CounterStyleManager::CleanRetiredStyles()
{
- nsTArray<CounterStyle*> list(Move(mRetiredStyles));
+ nsTArray<CounterStyle*> list(std::move(mRetiredStyles));
for (CounterStyle* style : list) {
DestroyCounterStyle(style);
}
}
} // namespace mozilla
--- a/layout/style/FontFaceSet.cpp
+++ b/layout/style/FontFaceSet.cpp
@@ -1806,21 +1806,21 @@ FontFaceSet::CheckLoadingFinished()
mNonRuleFaces[i].mLoadEventShouldFire = false;
} else if (f->Status() == FontFaceLoadStatus::Error) {
failed.AppendElement(*f);
mNonRuleFaces[i].mLoadEventShouldFire = false;
}
}
DispatchLoadingFinishedEvent(NS_LITERAL_STRING("loadingdone"),
- Move(loaded));
+ std::move(loaded));
if (!failed.IsEmpty()) {
DispatchLoadingFinishedEvent(NS_LITERAL_STRING("loadingerror"),
- Move(failed));
+ std::move(failed));
}
}
void
FontFaceSet::DispatchLoadingFinishedEvent(
const nsAString& aType,
nsTArray<OwningNonNull<FontFace>>&& aFontFaces)
{
--- a/layout/style/GroupRule.cpp
+++ b/layout/style/GroupRule.cpp
@@ -16,17 +16,17 @@
using namespace mozilla::dom;
namespace mozilla {
namespace css {
GroupRule::GroupRule(already_AddRefed<ServoCssRules> aRules,
uint32_t aLineNumber, uint32_t aColumnNumber)
: Rule(aLineNumber, aColumnNumber)
- , mRuleList(new ServoCSSRuleList(Move(aRules), nullptr))
+ , mRuleList(new ServoCSSRuleList(std::move(aRules), nullptr))
{
mRuleList->SetParentRule(this);
}
GroupRule::~GroupRule()
{
MOZ_ASSERT(!mSheet, "SetStyleSheet should have been called");
if (mRuleList) {
--- a/layout/style/Loader.cpp
+++ b/layout/style/Loader.cpp
@@ -1037,17 +1037,17 @@ Loader::CreateSheet(nsIURI* aURI,
!sheet->IsComplete(),
"Unexpected complete sheet with forced unique inner");
NS_ASSERTION(sheet->IsComplete() ||
aSheetState != eSheetComplete,
"Sheet thinks it's not complete while we think it is");
RefPtr<StyleSheet> clonedSheet =
sheet->Clone(nullptr, nullptr, nullptr, nullptr);
- *aSheet = Move(clonedSheet);
+ *aSheet = std::move(clonedSheet);
if (*aSheet && fromCompleteSheets &&
!sheet->GetOwnerNode() &&
!sheet->GetParentSheet()) {
// The sheet we're cloning isn't actually referenced by
// anyone. Replace it in the cache, so that if our CSSOM is
// later modified we don't end up with two copies of our inner
// hanging around.
URIPrincipalReferrerPolicyAndCORSModeHashKey key(aURI, aLoaderPrincipal, aCORSMode, aReferrerPolicy);
@@ -1661,17 +1661,17 @@ Loader::DoParseSheetServo(const nsACStri
// This parse does not need to be synchronous. \o/
//
// Note that we need to block onload because there may be no network requests
// pending.
BlockOnload();
RefPtr<SheetLoadData> loadData = aLoadData;
nsCOMPtr<nsISerialEventTarget> target = DispatchTarget();
sheet->ParseSheet(this, aBytes, aLoadData)->Then(target, __func__,
- [loadData = Move(loadData)](bool aDummy) {
+ [loadData = std::move(loadData)](bool aDummy) {
MOZ_ASSERT(NS_IsMainThread());
loadData->mIsBeingParsed = false;
loadData->mLoader->UnblockOnload(/* aFireSync = */ false);
// If there are no child sheets outstanding, mark us as complete.
// Otherwise, the children are holding strong refs to the data and
// will call SheetComplete() on it when they complete.
if (loadData->mPendingChildren == 0) {
loadData->mLoader->SheetComplete(loadData, NS_OK);
--- a/layout/style/ServoBindings.cpp
+++ b/layout/style/ServoBindings.cpp
@@ -1460,17 +1460,17 @@ void
Gecko_SetCounterStyleToSymbols(CounterStylePtr* aPtr, uint8_t aSymbolsType,
nsACString const* const* aSymbols,
uint32_t aSymbolsCount)
{
nsTArray<nsString> symbols(aSymbolsCount);
for (uint32_t i = 0; i < aSymbolsCount; i++) {
symbols.AppendElement(NS_ConvertUTF8toUTF16(*aSymbols[i]));
}
- *aPtr = new AnonymousCounterStyle(aSymbolsType, Move(symbols));
+ *aPtr = new AnonymousCounterStyle(aSymbolsType, std::move(symbols));
}
void
Gecko_SetCounterStyleToString(CounterStylePtr* aPtr, const nsACString* aSymbol)
{
*aPtr = new AnonymousCounterStyle(NS_ConvertUTF8toUTF16(*aSymbol));
}
@@ -2600,18 +2600,18 @@ NS_IMPL_THREADSAFE_FFI_REFCOUNTING(Sheet
void
Gecko_StyleSheet_FinishAsyncParse(SheetLoadDataHolder* aData,
RawServoStyleSheetContentsStrong aSheetContents)
{
RefPtr<SheetLoadDataHolder> loadData = aData;
RefPtr<RawServoStyleSheetContents> sheetContents = aSheetContents.Consume();
NS_DispatchToMainThread(NS_NewRunnableFunction(__func__,
- [d = Move(loadData),
- s = Move(sheetContents)]() mutable {
+ [d = std::move(loadData),
+ s = std::move(sheetContents)]() mutable {
MOZ_ASSERT(NS_IsMainThread());
d->get()->mSheet->FinishAsyncParse(s.forget());
}));
}
static already_AddRefed<StyleSheet>
LoadImportSheet(css::Loader* aLoader,
StyleSheet* aParent,
@@ -2620,17 +2620,17 @@ LoadImportSheet(css::Loader* aLoader,
css::URLValue* aURL,
already_AddRefed<RawServoMediaList> aMediaList)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aLoader, "Should've catched this before");
MOZ_ASSERT(aParent, "Only used for @import, so parent should exist!");
MOZ_ASSERT(aURL, "Invalid URLs shouldn't be loaded!");
- RefPtr<dom::MediaList> media = new MediaList(Move(aMediaList));
+ RefPtr<dom::MediaList> media = new MediaList(std::move(aMediaList));
nsCOMPtr<nsIURI> uri = aURL->GetURI();
nsresult rv = uri ? NS_OK : NS_ERROR_FAILURE;
StyleSheet* previousFirstChild = aParent->GetFirstChild();
if (NS_SUCCEEDED(rv)) {
rv = aLoader->LoadChildSheet(aParent, aParentLoadData, uri, media, aReusableSheets);
}
@@ -2682,20 +2682,20 @@ Gecko_LoadStyleSheetAsync(css::SheetLoad
RawServoMediaListStrong aMediaList,
RawServoImportRuleStrong aImportRule)
{
RefPtr<SheetLoadDataHolder> loadData = aParentData;
RefPtr<css::URLValue> urlVal = aServoURL.IntoCssUrl();
RefPtr<RawServoMediaList> mediaList = aMediaList.Consume();
RefPtr<RawServoImportRule> importRule = aImportRule.Consume();
NS_DispatchToMainThread(NS_NewRunnableFunction(__func__,
- [data = Move(loadData),
- url = Move(urlVal),
- media = Move(mediaList),
- import = Move(importRule)]() mutable {
+ [data = std::move(loadData),
+ url = std::move(urlVal),
+ media = std::move(mediaList),
+ import = std::move(importRule)]() mutable {
MOZ_ASSERT(NS_IsMainThread());
SheetLoadData* d = data->get();
RefPtr<StyleSheet> sheet =
LoadImportSheet(d->mLoader, d->mSheet, d, nullptr, url, media.forget());
Servo_ImportRule_SetSheet(import, sheet);
}));
}
--- a/layout/style/ServoCounterStyleRule.h
+++ b/layout/style/ServoCounterStyleRule.h
@@ -15,17 +15,17 @@ struct RawServoCounterStyleRule;
namespace mozilla {
class ServoCounterStyleRule final : public css::Rule
{
public:
ServoCounterStyleRule(already_AddRefed<RawServoCounterStyleRule> aRawRule,
uint32_t aLine, uint32_t aColumn)
: mozilla::css::Rule(aLine, aColumn)
- , mRawRule(Move(aRawRule))
+ , mRawRule(std::move(aRawRule))
{
}
private:
ServoCounterStyleRule(const ServoCounterStyleRule& aCopy) = delete;
~ServoCounterStyleRule() = default;
public:
--- a/layout/style/ServoDocumentRule.cpp
+++ b/layout/style/ServoDocumentRule.cpp
@@ -12,17 +12,17 @@
using namespace mozilla::dom;
namespace mozilla {
ServoDocumentRule::ServoDocumentRule(RefPtr<RawServoDocumentRule> aRawRule,
uint32_t aLine, uint32_t aColumn)
: CSSMozDocumentRule(Servo_DocumentRule_GetRules(aRawRule).Consume(),
aLine, aColumn)
- , mRawRule(Move(aRawRule))
+ , mRawRule(std::move(aRawRule))
{
}
ServoDocumentRule::~ServoDocumentRule()
{
}
NS_IMPL_ADDREF_INHERITED(ServoDocumentRule, CSSMozDocumentRule)
--- a/layout/style/ServoFontFaceRule.h
+++ b/layout/style/ServoFontFaceRule.h
@@ -28,17 +28,17 @@ public:
JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) final;
protected:
// For accessing the constructor.
friend class ServoFontFaceRule;
explicit ServoFontFaceRuleDecl(already_AddRefed<RawServoFontFaceRule> aDecl)
- : mRawRule(Move(aDecl)) {}
+ : mRawRule(std::move(aDecl)) {}
~ServoFontFaceRuleDecl() = default;
inline ServoFontFaceRule* ContainingRule();
inline const ServoFontFaceRule* ContainingRule() const;
RefPtr<RawServoFontFaceRule> mRawRule;
@@ -47,17 +47,17 @@ private:
};
class ServoFontFaceRule final : public css::Rule
{
public:
ServoFontFaceRule(already_AddRefed<RawServoFontFaceRule> aRawRule,
uint32_t aLine, uint32_t aColumn)
: css::Rule(aLine, aColumn)
- , mDecl(Move(aRawRule))
+ , mDecl(std::move(aRawRule))
{}
ServoFontFaceRule(const ServoFontFaceRule&) = delete;
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED(
ServoFontFaceRule, css::Rule)
bool IsCCLeaf() const final;
--- a/layout/style/ServoFontFeatureValuesRule.cpp
+++ b/layout/style/ServoFontFeatureValuesRule.cpp
@@ -13,17 +13,17 @@
using namespace mozilla::dom;
namespace mozilla {
ServoFontFeatureValuesRule::ServoFontFeatureValuesRule(
RefPtr<RawServoFontFeatureValuesRule> aRawRule,
uint32_t aLine, uint32_t aColumn)
: CSSFontFeatureValuesRule(aLine, aColumn)
- , mRawRule(Move(aRawRule))
+ , mRawRule(std::move(aRawRule))
{
}
ServoFontFeatureValuesRule::~ServoFontFeatureValuesRule()
{
}
size_t
--- a/layout/style/ServoImportRule.cpp
+++ b/layout/style/ServoImportRule.cpp
@@ -12,17 +12,17 @@
#include "mozilla/StyleSheet.h"
namespace mozilla {
ServoImportRule::ServoImportRule(RefPtr<RawServoImportRule> aRawRule,
uint32_t aLine,
uint32_t aColumn)
: CSSImportRule(aLine, aColumn)
- , mRawRule(Move(aRawRule))
+ , mRawRule(std::move(aRawRule))
{
const auto* sheet = Servo_ImportRule_GetSheet(mRawRule.get());
MOZ_ASSERT(sheet);
mChildSheet = const_cast<StyleSheet*>(sheet);
mChildSheet->SetOwnerRule(this);
}
ServoImportRule::~ServoImportRule()
--- a/layout/style/ServoKeyframesRule.cpp
+++ b/layout/style/ServoKeyframesRule.cpp
@@ -154,17 +154,17 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
// -------------------------------------------
// ServoKeyframesRule
//
ServoKeyframesRule::ServoKeyframesRule(RefPtr<RawServoKeyframesRule> aRawRule,
uint32_t aLine, uint32_t aColumn)
: dom::CSSKeyframesRule(aLine, aColumn)
- , mRawRule(Move(aRawRule))
+ , mRawRule(std::move(aRawRule))
{
}
ServoKeyframesRule::~ServoKeyframesRule()
{
if (mKeyframeList) {
mKeyframeList->DropReference();
}
--- a/layout/style/ServoMediaRule.cpp
+++ b/layout/style/ServoMediaRule.cpp
@@ -13,17 +13,17 @@
using namespace mozilla::dom;
namespace mozilla {
ServoMediaRule::ServoMediaRule(RefPtr<RawServoMediaRule> aRawRule,
uint32_t aLine, uint32_t aColumn)
: CSSMediaRule(Servo_MediaRule_GetRules(aRawRule).Consume(), aLine, aColumn)
- , mRawRule(Move(aRawRule))
+ , mRawRule(std::move(aRawRule))
{
}
ServoMediaRule::~ServoMediaRule()
{
if (mMediaList) {
mMediaList->SetStyleSheet(nullptr);
}
--- a/layout/style/ServoNamespaceRule.h
+++ b/layout/style/ServoNamespaceRule.h
@@ -13,17 +13,17 @@
namespace mozilla {
class ServoNamespaceRule : public dom::CSSNamespaceRule
{
public:
ServoNamespaceRule(already_AddRefed<RawServoNamespaceRule> aRule,
uint32_t aLine, uint32_t aColumn)
: CSSNamespaceRule(aLine, aColumn)
- , mRawRule(Move(aRule))
+ , mRawRule(std::move(aRule))
{
}
NS_INLINE_DECL_REFCOUNTING_INHERITED(ServoNamespaceRule,
dom::CSSNamespaceRule)
#ifdef DEBUG
void List(FILE* out = stdout, int32_t aIndent = 0) const final;
--- a/layout/style/ServoPageRule.cpp
+++ b/layout/style/ServoPageRule.cpp
@@ -15,17 +15,17 @@
using namespace mozilla::dom;
namespace mozilla {
// -- ServoPageRuleDeclaration ---------------------------------------
ServoPageRuleDeclaration::ServoPageRuleDeclaration(
already_AddRefed<RawServoDeclarationBlock> aDecls)
- : mDecls(new ServoDeclarationBlock(Move(aDecls)))
+ : mDecls(new ServoDeclarationBlock(std::move(aDecls)))
{
}
ServoPageRuleDeclaration::~ServoPageRuleDeclaration()
{
mDecls->SetOwningRule(nullptr);
}
@@ -94,17 +94,17 @@ ServoPageRuleDeclaration::GetParsingEnvi
return GetParsingEnvironmentForRule(Rule());
}
// -- ServoPageRule --------------------------------------------------
ServoPageRule::ServoPageRule(RefPtr<RawServoPageRule> aRawRule,
uint32_t aLine, uint32_t aColumn)
: CSSPageRule(aLine, aColumn)
- , mRawRule(Move(aRawRule))
+ , mRawRule(std::move(aRawRule))
, mDecls(Servo_PageRule_GetStyle(mRawRule).Consume())
{
}
ServoPageRule::~ServoPageRule()
{
}
--- a/layout/style/ServoStyleRule.cpp
+++ b/layout/style/ServoStyleRule.cpp
@@ -18,17 +18,17 @@
using namespace mozilla::dom;
namespace mozilla {
// -- ServoStyleRuleDeclaration ---------------------------------------
ServoStyleRuleDeclaration::ServoStyleRuleDeclaration(
already_AddRefed<RawServoDeclarationBlock> aDecls)
- : mDecls(new ServoDeclarationBlock(Move(aDecls)))
+ : mDecls(new ServoDeclarationBlock(std::move(aDecls)))
{
}
ServoStyleRuleDeclaration::~ServoStyleRuleDeclaration()
{
mDecls->SetOwningRule(nullptr);
}
--- a/layout/style/ServoSupportsRule.cpp
+++ b/layout/style/ServoSupportsRule.cpp
@@ -13,17 +13,17 @@
using namespace mozilla::dom;
namespace mozilla {
ServoSupportsRule::ServoSupportsRule(RefPtr<RawServoSupportsRule> aRawRule,
uint32_t aLine, uint32_t aColumn)
: CSSSupportsRule(Servo_SupportsRule_GetRules(aRawRule).Consume(),
aLine, aColumn)
- , mRawRule(Move(aRawRule))
+ , mRawRule(std::move(aRawRule))
{
}
ServoSupportsRule::~ServoSupportsRule()
{
}
NS_IMPL_ADDREF_INHERITED(ServoSupportsRule, CSSSupportsRule)
--- a/layout/style/StyleAnimationValue.h
+++ b/layout/style/StyleAnimationValue.h
@@ -45,30 +45,30 @@ struct AnimationValue
{
explicit AnimationValue(const RefPtr<RawServoAnimationValue>& aValue)
: mServo(aValue) { }
AnimationValue() = default;
AnimationValue(const AnimationValue& aOther)
: mServo(aOther.mServo) { }
AnimationValue(AnimationValue&& aOther)
- : mServo(Move(aOther.mServo)) { }
+ : mServo(std::move(aOther.mServo)) { }
AnimationValue& operator=(const AnimationValue& aOther)
{
if (this != &aOther) {
mServo = aOther.mServo;
}
return *this;
}
AnimationValue& operator=(AnimationValue&& aOther)
{
MOZ_ASSERT(this != &aOther, "Do not move itself");
if (this != &aOther) {
- mServo = Move(aOther.mServo);
+ mServo = std::move(aOther.mServo);
}
return *this;
}
bool operator==(const AnimationValue& aOther) const;
bool operator!=(const AnimationValue& aOther) const;
bool IsNull() const
--- a/layout/style/StyleSheet.cpp
+++ b/layout/style/StyleSheet.cpp
@@ -1041,17 +1041,17 @@ StyleSheet::ParseSheet(css::Loader* aLoa
Servo_StyleSheet_FromUTF8BytesAsync(loadDataHolder,
Inner().mURLData,
&aBytes,
mParsingMode,
aLoadData->mLineNumber,
aLoader->GetCompatibilityMode());
}
- return Move(p);
+ return std::move(p);
}
void
StyleSheet::FinishAsyncParse(already_AddRefed<RawServoStyleSheetContents> aSheetContents)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(!mParsePromise.IsEmpty());
Inner().mContents = aSheetContents;
--- a/layout/style/URLExtraData.h
+++ b/layout/style/URLExtraData.h
@@ -19,19 +19,19 @@
namespace mozilla {
struct URLExtraData
{
URLExtraData(already_AddRefed<nsIURI> aBaseURI,
already_AddRefed<nsIURI> aReferrer,
already_AddRefed<nsIPrincipal> aPrincipal)
- : mBaseURI(Move(aBaseURI))
- , mReferrer(Move(aReferrer))
- , mPrincipal(Move(aPrincipal))
+ : mBaseURI(std::move(aBaseURI))
+ , mReferrer(std::move(aReferrer))
+ , mPrincipal(std::move(aPrincipal))
// When we hold the URI data of a style sheet, mReferrer is always
// equal to the sheet URI.
, mIsChrome(mReferrer ? dom::IsChromeURI(mReferrer) : false)
{
MOZ_ASSERT(mBaseURI);
}
URLExtraData(nsIURI* aBaseURI, nsIURI* aReferrer, nsIPrincipal* aPrincipal)
--- a/layout/style/nsAnimationManager.cpp
+++ b/layout/style/nsAnimationManager.cpp
@@ -298,17 +298,17 @@ CSSAnimation::QueueEvents(const StickyTi
appendAnimationEvent(eAnimationStart, intervalEndTime, endTimeStamp);
}
break;
}
mPreviousPhase = currentPhase;
mPreviousIteration = currentIteration;
if (!events.IsEmpty()) {
- presContext->AnimationEventDispatcher()->QueueEvents(Move(events));
+ presContext->AnimationEventDispatcher()->QueueEvents(std::move(events));
}
}
void
CSSAnimation::UpdateTiming(SeekFlag aSeekFlag, SyncNotifyFlag aSyncNotifyFlag)
{
if (mNeedsNewAnimationIndexWhenRun &&
PlayState() != AnimationPlayState::Idle) {
@@ -367,17 +367,17 @@ public:
MOZ_ASSERT(styleSet);
return styleSet->GetKeyframesForName(aElement,
aName,
aTimingFunction,
aKeyframes);
}
void SetKeyframes(KeyframeEffect& aEffect, nsTArray<Keyframe>&& aKeyframes)
{
- aEffect.SetKeyframes(Move(aKeyframes), mComputedStyle);
+ aEffect.SetKeyframes(std::move(aKeyframes), mComputedStyle);
}
// Currently all the animation building code in this file is based on
// assumption that creating and removing animations should *not* trigger
// additional restyles since those changes will be handled within the same
// restyle.
//
// While that is true for the Gecko style backend, it is not true for the
@@ -433,17 +433,17 @@ UpdateOldAnimationPropertiesWithNew(
// identity (and any expando properties attached to it).
if (aOld.GetEffect()) {
dom::AnimationEffect* oldEffect = aOld.GetEffect();
animationChanged = oldEffect->SpecifiedTiming() != aNewTiming;
oldEffect->SetSpecifiedTiming(aNewTiming);
KeyframeEffect* oldKeyframeEffect = oldEffect->AsKeyframeEffect();
if (oldKeyframeEffect) {
- aBuilder.SetKeyframes(*oldKeyframeEffect, Move(aNewKeyframes));
+ aBuilder.SetKeyframes(*oldKeyframeEffect, std::move(aNewKeyframes));
}
}
// Handle changes in play state. If the animation is idle, however,
// changes to animation-play-state should *not* restart it.
if (aOld.PlayState() != AnimationPlayState::Idle) {
// CSSAnimation takes care of override behavior so that,
// for example, if the author has called pause(), that will
@@ -514,30 +514,30 @@ BuildAnimation(nsPresContext* aPresConte
// old list of animations.
// This means that we honor dynamic changes, which isn't what the
// spec says to do, but WebKit seems to honor at least some of
// them. See
// http://lists.w3.org/Archives/Public/www-style/2011Apr/0079.html
// In order to honor what the spec said, we'd copy more data over.
UpdateOldAnimationPropertiesWithNew(*oldAnim,
timing,
- Move(keyframes),
+ std::move(keyframes),
isStylePaused,
aBuilder);
return oldAnim.forget();
}
// mTarget is non-null here, so we emplace it directly.
Maybe<OwningAnimationTarget> target;
target.emplace(aTarget.mElement, aTarget.mPseudoType);
KeyframeEffectParams effectOptions;
RefPtr<KeyframeEffect> effect =
new KeyframeEffect(aPresContext->Document(), target, timing, effectOptions);
- aBuilder.SetKeyframes(*effect, Move(keyframes));
+ aBuilder.SetKeyframes(*effect, std::move(keyframes));
RefPtr<CSSAnimation> animation =
new CSSAnimation(aPresContext->Document()->GetScopeObject(), animationName);
animation->SetOwningElement(
OwningElementRef(*aTarget.mElement, aTarget.mPseudoType));
animation->SetTimelineNoUpdate(aTarget.mElement->OwnerDoc()->Timeline());
animation->SetEffectNoUpdate(effect);
--- a/layout/style/nsCSSValue.cpp
+++ b/layout/style/nsCSSValue.cpp
@@ -558,17 +558,17 @@ void nsCSSValue::SetDependentListValue(n
}
void
nsCSSValue::AdoptListValue(UniquePtr<nsCSSValueList> aValue)
{
// We have to copy the first element since for owned lists the first
// element should be an nsCSSValueList_heap object.
SetListValue();
- mValue.mList->mValue = Move(aValue->mValue);
+ mValue.mList->mValue = std::move(aValue->mValue);
mValue.mList->mNext = aValue->mNext;
aValue->mNext = nullptr;
aValue.reset();
}
nsCSSValuePairList* nsCSSValue::SetPairListValue()
{
Reset();
@@ -588,18 +588,18 @@ void nsCSSValue::SetDependentPairListVal
}
void
nsCSSValue::AdoptPairListValue(UniquePtr<nsCSSValuePairList> aValue)
{
// We have to copy the first element, since for owned pair lists, the first
// element should be an nsCSSValuePairList_heap object.
SetPairListValue();
- mValue.mPairList->mXValue = Move(aValue->mXValue);
- mValue.mPairList->mYValue = Move(aValue->mYValue);
+ mValue.mPairList->mXValue = std::move(aValue->mXValue);
+ mValue.mPairList->mYValue = std::move(aValue->mYValue);
mValue.mPairList->mNext = aValue->mNext;
aValue->mNext = nullptr;
aValue.reset();
}
void nsCSSValue::SetAutoValue()
{
Reset();
@@ -1156,28 +1156,28 @@ nsCSSValue::Array::SizeOfIncludingThis(m
n += mArray[i].SizeOfExcludingThis(aMallocSizeOf);
}
return n;
}
css::URLValueData::URLValueData(already_AddRefed<nsIURI> aURI,
ServoRawOffsetArc<RustString> aString,
already_AddRefed<URLExtraData> aExtraData)
- : mURI(Move(aURI))
- , mExtraData(Move(aExtraData))
+ : mURI(std::move(aURI))
+ , mExtraData(std::move(aExtraData))
, mURIResolved(true)
, mString(aString)
{
MOZ_ASSERT(mExtraData);
MOZ_ASSERT(mExtraData->GetPrincipal());
}
css::URLValueData::URLValueData(ServoRawOffsetArc<RustString> aString,
already_AddRefed<URLExtraData> aExtraData)
- : mExtraData(Move(aExtraData))
+ : mExtraData(std::move(aExtraData))
, mURIResolved(false)
, mString(aString)
{
MOZ_ASSERT(mExtraData);
MOZ_ASSERT(mExtraData->GetPrincipal());
}
css::URLValueData::~URLValueData()
@@ -1388,26 +1388,26 @@ css::URLValue::SizeOfIncludingThis(mozil
return n;
}
css::ImageValue::ImageValue(nsIURI* aURI,
ServoRawOffsetArc<RustString> aString,
already_AddRefed<URLExtraData> aExtraData,
nsIDocument* aDocument,
CORSMode aCORSMode)
- : URLValueData(do_AddRef(aURI), aString, Move(aExtraData))
+ : URLValueData(do_AddRef(aURI), aString, std::move(aExtraData))
{
mCORSMode = aCORSMode;
Initialize(aDocument);
}
css::ImageValue::ImageValue(ServoRawOffsetArc<RustString> aString,
already_AddRefed<URLExtraData> aExtraData,
CORSMode aCORSMode)
- : URLValueData(aString, Move(aExtraData))
+ : URLValueData(aString, std::move(aExtraData))
{
mCORSMode = aCORSMode;
}
/*static*/ already_AddRefed<css::ImageValue>
css::ImageValue::CreateFromURLValue(URLValue* aUrl,
nsIDocument* aDocument,
CORSMode aCORSMode)
--- a/layout/style/nsCSSValue.h
+++ b/layout/style/nsCSSValue.h
@@ -204,17 +204,17 @@ private:
friend struct ImageValue;
};
struct URLValue final : public URLValueData
{
URLValue(ServoRawOffsetArc<RustString> aString,
already_AddRefed<URLExtraData> aExtraData)
- : URLValueData(aString, Move(aExtraData))
+ : URLValueData(aString, std::move(aExtraData))
{ }
URLValue(const URLValue&) = delete;
URLValue& operator=(const URLValue&) = delete;
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
};
--- a/layout/style/nsComputedDOMStyle.cpp
+++ b/layout/style/nsComputedDOMStyle.cpp
@@ -948,17 +948,17 @@ nsComputedDOMStyle::UpdateCurrentStyleSo
// No need to re-get the generation, even though GetComputedStyle
// will flush, since we flushed style at the top of this function.
// We don't need to check this if we only flushed the parent.
NS_ASSERTION(!needsToFlush ||
currentGeneration ==
mPresShell->GetPresContext()->GetUndisplayedRestyleGeneration(),
"why should we have flushed style again?");
- SetResolvedComputedStyle(Move(resolvedComputedStyle), currentGeneration);
+ SetResolvedComputedStyle(std::move(resolvedComputedStyle), currentGeneration);
NS_ASSERTION(mPseudo || !mComputedStyle->HasPseudoElementData(),
"should not have pseudo-element data");
}
// mExposeVisitedStyle is set to true only by testing APIs that
// require chrome privilege.
MOZ_ASSERT(!mExposeVisitedStyle || nsContentUtils::IsCallerChrome(),
"mExposeVisitedStyle set incorrectly");
--- a/layout/style/nsDOMCSSValueList.cpp
+++ b/layout/style/nsDOMCSSValueList.cpp
@@ -20,17 +20,17 @@ nsDOMCSSValueList::nsDOMCSSValueList(boo
}
nsDOMCSSValueList::~nsDOMCSSValueList() = default;
void
nsDOMCSSValueList::AppendCSSValue(already_AddRefed<CSSValue> aValue)
{
RefPtr<CSSValue> val = aValue;
- mCSSValues.AppendElement(Move(val));
+ mCSSValues.AppendElement(std::move(val));
}
void
nsDOMCSSValueList::GetCssText(nsAString& aCssText)
{
aCssText.Truncate();
uint32_t count = mCSSValues.Length();
--- a/layout/style/nsStyleStruct.cpp
+++ b/layout/style/nsStyleStruct.cpp
@@ -617,17 +617,17 @@ nsStyleList::SetQuotesNone()
}
mQuotes = sNoneQuotes;
}
void
nsStyleList::SetQuotes(nsStyleQuoteValues::QuotePairArray&& aValues)
{
mQuotes = new nsStyleQuoteValues;
- mQuotes->mQuotePairs = Move(aValues);
+ mQuotes->mQuotePairs = std::move(aValues);
}
const nsStyleQuoteValues::QuotePairArray&
nsStyleList::GetQuotePairs() const
{
return mQuotes->mQuotePairs;
}
@@ -1042,17 +1042,17 @@ StyleShapeSource::SetURL(css::URLValue*
mShapeImage->SetURLValue(do_AddRef(aValue));
mType = StyleShapeSourceType::URL;
}
void
StyleShapeSource::SetShapeImage(UniquePtr<nsStyleImage> aShapeImage)
{
MOZ_ASSERT(aShapeImage);
- mShapeImage = Move(aShapeImage);
+ mShapeImage = std::move(aShapeImage);
mType = StyleShapeSourceType::Image;
}
imgIRequest*
StyleShapeSource::GetShapeImageData() const
{
if (mType != StyleShapeSourceType::Image) {
return nullptr;
@@ -1063,17 +1063,17 @@ StyleShapeSource::GetShapeImageData() co
return mShapeImage->GetImageData();
}
void
StyleShapeSource::SetBasicShape(UniquePtr<StyleBasicShape> aBasicShape,
StyleGeometryBox aReferenceBox)
{
MOZ_ASSERT(aBasicShape);
- mBasicShape = Move(aBasicShape);
+ mBasicShape = std::move(aBasicShape);
mReferenceBox = aReferenceBox;
mType = StyleShapeSourceType::Shape;
}
void
StyleShapeSource::SetReferenceBox(StyleGeometryBox aReferenceBox)
{
mReferenceBox = aReferenceBox;
@@ -2328,17 +2328,17 @@ nsStyleImage::DoCopy(const nsStyleImage&
} else if (aOther.mType == eStyleImageType_URL) {
SetURLValue(do_AddRef(aOther.mURLValue));
}
UniquePtr<nsStyleSides> cropRectCopy;
if (aOther.mCropRect) {
cropRectCopy = MakeUnique<nsStyleSides>(*aOther.mCropRect.get());
}
- SetCropRect(Move(cropRectCopy));
+ SetCropRect(std::move(cropRectCopy));
}
void
nsStyleImage::SetNull()
{
if (mType == eStyleImageType_Gradient) {
mGradient->Release();
} else if (mType == eStyleImageType_Image) {
@@ -2399,17 +2399,17 @@ nsStyleImage::SetElementId(already_AddRe
mElementId = atom.forget().take();
mType = eStyleImageType_Element;
}
}
void
nsStyleImage::SetCropRect(UniquePtr<nsStyleSides> aCropRect)
{
- mCropRect = Move(aCropRect);
+ mCropRect = std::move(aCropRect);
}
void
nsStyleImage::SetURLValue(already_AddRefed<URLValue> aValue)
{
RefPtr<URLValue> value = aValue;
if (mType != eStyleImageType_Null) {
@@ -2879,17 +2879,17 @@ nsStyleImageLayers::operator=(nsStyleIma
mRepeatCount = aOther.mRepeatCount;
mPositionXCount = aOther.mPositionXCount;
mPositionYCount = aOther.mPositionYCount;
mImageCount = aOther.mImageCount;
mSizeCount = aOther.mSizeCount;
mMaskModeCount = aOther.mMaskModeCount;
mBlendModeCount = aOther.mBlendModeCount;
mCompositeCount = aOther.mCompositeCount;
- mLayers = Move(aOther.mLayers);
+ mLayers = std::move(aOther.mLayers);
uint32_t count = mLayers.Length();
if (count != aOther.mLayers.Length()) {
NS_WARNING("truncating counts due to out-of-memory");
mAttachmentCount = std::max(mAttachmentCount, count);
mClipCount = std::max(mClipCount, count);
mOriginCount = std::max(mOriginCount, count);
mRepeatCount = std::max(mRepeatCount, count);
--- a/layout/style/nsTransitionManager.cpp
+++ b/layout/style/nsTransitionManager.cpp
@@ -113,17 +113,17 @@ ElementPropertyTransition::UpdateStartVa
AnimationValue startValue;
startValue.mServo =
Servo_AnimationValues_Interpolate(replacedFrom.mServo,
replacedTo.mServo,
valuePosition).Consume();
if (startValue.mServo) {
mKeyframes[0].mPropertyValues[0].mServoDeclarationBlock =
Servo_AnimationValue_Uncompute(startValue.mServo).Consume();
- mProperties[0].mSegments[0].mFromValue = Move(startValue);
+ mProperties[0].mSegments[0].mFromValue = std::move(startValue);
}
}
mReplacedTransition.reset();
}
////////////////////////// CSSTransition ////////////////////////////
@@ -316,17 +316,17 @@ CSSTransition::QueueEvents(const StickyT
intervalStartTime,
endTimeStamp);
}
break;
}
mPreviousTransitionPhase = currentPhase;
if (!events.IsEmpty()) {
- presContext->AnimationEventDispatcher()->QueueEvents(Move(events));
+ presContext->AnimationEventDispatcher()->QueueEvents(std::move(events));
}
}
void
CSSTransition::Tick()
{
Animation::Tick();
QueueEvents();
@@ -601,39 +601,39 @@ AppendKeyframe(double aOffset,
{
Keyframe& frame = *aKeyframes.AppendElement();
frame.mOffset.emplace(aOffset);
if (aValue.mServo) {
RefPtr<RawServoDeclarationBlock> decl =
Servo_AnimationValue_Uncompute(aValue.mServo).Consume();
frame.mPropertyValues.AppendElement(
- Move(PropertyValuePair(aProperty, Move(decl))));
+ std::move(PropertyValuePair(aProperty, std::move(decl))));
} else {
MOZ_CRASH("old style system disabled");
}
return frame;
}
static nsTArray<Keyframe>
GetTransitionKeyframes(nsCSSPropertyID aProperty,
AnimationValue&& aStartValue,
AnimationValue&& aEndValue,
const nsTimingFunction& aTimingFunction)
{
nsTArray<Keyframe> keyframes(2);
- Keyframe& fromFrame = AppendKeyframe(0.0, aProperty, Move(aStartValue),
+ Keyframe& fromFrame = AppendKeyframe(0.0, aProperty, std::move(aStartValue),
keyframes);
if (aTimingFunction.mType != nsTimingFunction::Type::Linear) {
fromFrame.mTimingFunction.emplace();
fromFrame.mTimingFunction->Init(aTimingFunction);
}
- AppendKeyframe(1.0, aProperty, Move(aEndValue), keyframes);
+ AppendKeyframe(1.0, aProperty, std::move(aEndValue), keyframes);
return keyframes;
}
static bool
IsTransitionable(nsCSSPropertyID aProperty)
{
return Servo_Property_IsTransitionable(aProperty);
@@ -828,17 +828,17 @@ nsTransitionManager::ConsiderInitiatingT
target.emplace(aElement, aPseudoType);
KeyframeEffectParams effectOptions;
RefPtr<ElementPropertyTransition> pt =
new ElementPropertyTransition(aElement->OwnerDoc(), target, timing,
startForReversingTest, reversePortion,
effectOptions);
pt->SetKeyframes(GetTransitionKeyframes(aProperty,
- Move(startValue), Move(endValue), tf),
+ std::move(startValue), std::move(endValue), tf),
&aNewStyle);
RefPtr<CSSTransition> animation =
new CSSTransition(mPresContext->Document()->GetScopeObject());
animation->SetOwningElement(OwningElementRef(*aElement, aPseudoType));
animation->SetTimelineNoUpdate(timeline);
animation->SetCreationSequence(
mPresContext->RestyleManager()->GetAnimationGeneration());
--- a/layout/xul/grid/nsGrid.cpp
+++ b/layout/xul/grid/nsGrid.cpp
@@ -319,26 +319,26 @@ nsGrid::BuildRows(nsIFrame* aBox, int32_
if (aIsHorizontal)
{
if (aRowCount > mRowCount) {
row = MakeUnique<nsGridRow[]>(aRowCount);
} else {
for (int32_t i=0; i < mRowCount; i++)
mRows[i].Init(nullptr, false);
- row = Move(mRows);
+ row = std::move(mRows);
}
} else {
if (aRowCount > mColumnCount) {
row = MakeUnique<nsGridRow[]>(aRowCount);
} else {
for (int32_t i=0; i < mColumnCount; i++)
mColumns[i].Init(nullptr, false);
- row = Move(mColumns);
+ row = std::move(mColumns);
}
}
// populate it if we can. If not it will contain only dynamic columns
if (aBox)
{
nsCOMPtr<nsIGridPart> monument = GetPartFromBox(aBox);
if (monument) {
@@ -366,17 +366,17 @@ nsGrid::BuildCellMap(int32_t aRows, int3
return MakeUnique<nsGridCell[]>(size);
}
// clear out cellmap
for (int32_t i=0; i < oldsize; i++) {
mCellMap[i].SetBoxInRow(nullptr);
mCellMap[i].SetBoxInColumn(nullptr);
}
- return Move(mCellMap);
+ return std::move(mCellMap);
}
/**
* Run through all the cells in the rows and columns and populate then with 2 cells. One from the row and one
* from the column
*/
void
nsGrid::PopulateCellMap(nsGridRow* aRows, nsGridRow* aColumns, int32_t aRowCount, int32_t aColumnCount, bool aIsHorizontal)
--- a/layout/xul/nsSplitterFrame.cpp
+++ b/layout/xul/nsSplitterFrame.cpp
@@ -783,17 +783,17 @@ nsSplitterFrameInner::MouseMove(Event* a
void
nsSplitterFrameInner::Reverse(UniquePtr<nsSplitterInfo[]>& aChildInfos, int32_t aCount)
{
UniquePtr<nsSplitterInfo[]> infos(new nsSplitterInfo[aCount]);
for (int i=0; i < aCount; i++)
infos[i] = aChildInfos[aCount - 1 - i];
- aChildInfos = Move(infos);
+ aChildInfos = std::move(infos);
}
bool
nsSplitterFrameInner::SupportsCollapseDirection
(
nsSplitterFrameInner::CollapseDirection aDirection
)
{
--- a/layout/xul/tree/nsTreeBodyFrame.cpp
+++ b/layout/xul/tree/nsTreeBodyFrame.cpp
@@ -4611,17 +4611,17 @@ nsTreeBodyFrame::PostScrollEvent()
return;
RefPtr<ScrollEvent> event = new ScrollEvent(this);
nsresult rv = mContent->OwnerDoc()->Dispatch(TaskCategory::Other,
do_AddRef(event));
if (NS_FAILED(rv)) {
NS_WARNING("failed to dispatch ScrollEvent");
} else {
- mScrollEvent = Move(event);
+ mScrollEvent = std::move(event);
}
}
void
nsTreeBodyFrame::ScrollbarActivityStarted() const
{
if (mScrollbarActivity) {
mScrollbarActivity->ActivityStarted();
--- a/layout/xul/tree/nsTreeContentView.cpp
+++ b/layout/xul/tree/nsTreeContentView.cpp
@@ -1275,17 +1275,17 @@ nsTreeContentView::SerializeSeparator(El
nsTArray<UniquePtr<Row>>& aRows)
{
if (aContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::hidden,
nsGkAtoms::_true, eCaseMatters))
return;
auto row = MakeUnique<Row>(aContent, aParentIndex);
row->SetSeparator(true);
- aRows.AppendElement(Move(row));
+ aRows.AppendElement(std::move(row));
}
void
nsTreeContentView::GetIndexInSubtree(nsIContent* aContainer,
nsIContent* aContent, int32_t* aIndex)
{
if (!aContainer->IsXULElement())
return;
@@ -1336,17 +1336,17 @@ nsTreeContentView::EnsureSubtree(int32_t
Serialize(child, aIndex, &index, rows);
// Insert |rows| into |mRows| at position |aIndex|, by first creating empty
// UniquePtr entries and then Move'ing |rows|'s entries into them. (Note
// that we can't simply use InsertElementsAt with an array argument, since
// the destination can't steal ownership from its const source argument.)
UniquePtr<Row>* newRows = mRows.InsertElementsAt(aIndex + 1,
rows.Length());
for (nsTArray<Row>::index_type i = 0; i < rows.Length(); i++) {
- newRows[i] = Move(rows[i]);
+ newRows[i] = std::move(rows[i]);
}
int32_t count = rows.Length();
row->mSubtreeSize += count;
UpdateSubtreeSizes(row->mParentIndex, count);
// Update parent indexes, but skip newly added rows.
// They already have correct values.
@@ -1415,17 +1415,17 @@ nsTreeContentView::InsertRow(int32_t aPa
} else if (aContent->IsXULElement(nsGkAtoms::treeseparator)) {
SerializeSeparator(aContent->AsElement(), aParentIndex, &aIndex, rows);
}
// We can't use InsertElementsAt since the destination can't steal
// ownership from its const source argument.
int32_t count = rows.Length();
for (nsTArray<Row>::index_type i = 0; i < size_t(count); i++) {
- mRows.InsertElementAt(aParentIndex + aIndex + i + 1, Move(rows[i]));
+ mRows.InsertElementAt(aParentIndex + aIndex + i + 1, std::move(rows[i]));
}
UpdateSubtreeSizes(aParentIndex, count);
// Update parent indexes, but skip added rows.
// They already have correct values.
UpdateParentIndexes(aParentIndex + aIndex, count + 1, count);
--- a/media/mtransport/dtlsidentity.cpp
+++ b/media/mtransport/dtlsidentity.cpp
@@ -141,18 +141,18 @@ RefPtr<DtlsIdentity> DtlsIdentity::Gener
rv = SEC_DerSignData(arena, signedCert, innerDER.data, innerDER.len,
private_key.get(),
SEC_OID_ANSIX962_ECDSA_SHA256_SIGNATURE);
if (rv != SECSuccess) {
return nullptr;
}
certificate->derCert = *signedCert;
- RefPtr<DtlsIdentity> identity = new DtlsIdentity(Move(private_key),
- Move(certificate),
+ RefPtr<DtlsIdentity> identity = new DtlsIdentity(std::move(private_key),
+ std::move(certificate),
ssl_kea_ecdh);
return identity.forget();
}
const std::string DtlsIdentity::DEFAULT_HASH_ALGORITHM = "sha-256";
nsresult DtlsIdentity::ComputeFingerprint(const std::string algorithm,
uint8_t *digest,
--- a/media/mtransport/dtlsidentity.h
+++ b/media/mtransport/dtlsidentity.h
@@ -21,17 +21,17 @@
namespace mozilla {
class DtlsIdentity final {
public:
// This constructor takes ownership of privkey and cert.
DtlsIdentity(UniqueSECKEYPrivateKey privkey,
UniqueCERTCertificate cert,
SSLKEAType authType)
- : private_key_(Move(privkey)), cert_(Move(cert)), auth_type_(authType) {}
+ : private_key_(std::move(privkey)), cert_(std::move(cert)), auth_type_(authType) {}
// This is only for use in tests, or for external linkage. It makes a (bad)
// instance of this class.
static RefPtr<DtlsIdentity> Generate();
// These don't create copies or transfer ownership. If you want these to live
// on, make a copy.
const UniqueCERTCertificate& cert() const { return cert_; }
--- a/media/mtransport/nricemediastream.cpp
+++ b/media/mtransport/nricemediastream.cpp
@@ -306,19 +306,19 @@ nsresult NrIceMediaStream::GetActivePair
return NS_ERROR_FAILURE;
UniquePtr<NrIceCandidate> remote(
MakeNrIceCandidate(*remote_int));
if (!remote)
return NS_ERROR_FAILURE;
if (localp)
- *localp = Move(local);
+ *localp = std::move(local);
if (remotep)
- *remotep = Move(remote);
+ *remotep = std::move(remote);
return NS_OK;
}
nsresult NrIceMediaStream::GetCandidatePairs(std::vector<NrIceCandidatePair>*
out_pairs) const {
MOZ_ASSERT(out_pairs);
--- a/media/mtransport/rlogconnector.cpp
+++ b/media/mtransport/rlogconnector.cpp
@@ -82,23 +82,23 @@ void RLogConnector::SetLogLimit(uint32_t
}
void RLogConnector::Log(int level, std::string&& log) {
MOZ_MTLOG(rLogLvlToMozLogLvl(level), log);
if (level <= LOG_INFO) {
OffTheBooksMutexAutoLock lock(mutex_);
if (disableCount_ == 0) {
- AddMsg(Move(log));
+ AddMsg(std::move(log));
}
}
}
void RLogConnector::AddMsg(std::string&& msg) {
- log_messages_.push_front(Move(msg));
+ log_messages_.push_front(std::move(msg));
RemoveOld();
}
inline void RLogConnector::RemoveOld() {
if (log_messages_.size() > log_limit_) {
log_messages_.resize(log_limit_);
}
}
--- a/media/mtransport/test/dummysocket.h
+++ b/media/mtransport/test/dummysocket.h
@@ -96,17 +96,17 @@ class DummySocket : public NrSocketBase
return 0;
}
virtual int write(const void *msg, size_t len, size_t *written) override {
size_t to_write = std::min(len, writable_);
if (to_write) {
UniquePtr<DataBuffer> msgbuf(new DataBuffer(static_cast<const uint8_t *>(msg), to_write));
- write_buffer_ = merge(Move(write_buffer_), Move(msgbuf));
+ write_buffer_ = merge(std::move(write_buffer_), std::move(msgbuf));
}
*written = to_write;
return 0;
}
virtual int read(void* buf, size_t maxlen, size_t *len) override {
--- a/media/mtransport/test/transport_unittests.cpp
+++ b/media/mtransport/test/transport_unittests.cpp
@@ -119,17 +119,17 @@ class TransportLayerLossy : public Trans
return downward_->SendPacket(data, len);
}
void SetLoss(uint32_t packet) {
loss_mask_ |= (1 << (packet & 32));
}
void SetInspector(UniquePtr<Inspector> inspector) {
- inspector_ = Move(inspector);
+ inspector_ = std::move(inspector);
}
void StateChange(TransportLayer *layer, State state) {
TL_SET_STATE(state);
}
void PacketReceived(TransportLayer *layer, const unsigned char *data,
size_t len) {
@@ -730,23 +730,23 @@ class TransportTestPeer : public sigslot
lossy_->SetLoss(loss);
}
void SetCombinePackets(bool combine) {
loopback_->CombinePackets(combine);
}
void SetInspector(UniquePtr<Inspector> inspector) {
- lossy_->SetInspector(Move(inspector));
+ lossy_->SetInspector(std::move(inspector));
}
void SetInspector(Inspector* in) {
UniquePtr<Inspector> inspector(in);
- lossy_->SetInspector(Move(inspector));
+ lossy_->SetInspector(std::move(inspector));
}
void SetCipherSuiteChanges(const std::vector<uint16_t>& enableThese,
const std::vector<uint16_t>& disableThese) {
disabled_cipersuites_ = disableThese;
enabled_cipersuites_ = enableThese;
}
--- a/media/mtransport/transportlayerdtls.cpp
+++ b/media/mtransport/transportlayerdtls.cpp
@@ -630,17 +630,17 @@ bool TransportLayerDtls::Setup() {
}
// Now start the handshake
rv = SSL_ResetHandshake(ssl_fd.get(), role_ == SERVER ? PR_TRUE : PR_FALSE);
if (rv != SECSuccess) {
MOZ_MTLOG(ML_ERROR, "Couldn't reset handshake");
return false;
}
- ssl_fd_ = Move(ssl_fd);
+ ssl_fd_ = std::move(ssl_fd);
// Finally, get ready to receive data
downward_->SignalStateChange.connect(this, &TransportLayerDtls::StateChange);
downward_->SignalPacketReceived.connect(this, &TransportLayerDtls::PacketReceived);
if (downward_->state() == TS_OPEN) {
TL_SET_STATE(TS_CONNECTING);
Handshake();
--- a/media/psshparser/PsshParser.cpp
+++ b/media/psshparser/PsshParser.cpp
@@ -188,11 +188,11 @@ ParseCENCInitData(const uint8_t* aInitDa
}
reader.ReadU32();
// Jump forwards to the end of the box, skipping any padding.
if (size) {
reader.Seek(end);
}
}
- aOutKeyIds = mozilla::Move(keyIds);
+ aOutKeyIds = std::move(keyIds);
return true;
}
--- a/media/webrtc/signaling/gtest/sdp_unittests.cpp
+++ b/media/webrtc/signaling/gtest/sdp_unittests.cpp
@@ -1506,39 +1506,39 @@ class NewSdpTest : public ::testing::Tes
public ::testing::WithParamInterface<
::testing::tuple<bool, bool> > {
public:
NewSdpTest() {}
void ParseSdp(const std::string &sdp, bool expectSuccess = true) {
if (::testing::get<1>(GetParam())) {
mSdpErrorHolder = &mSipccParser;
- mSdp = mozilla::Move(mSipccParser.Parse(sdp));
+ mSdp = std::move(mSipccParser.Parse(sdp));
} else {
mSdpErrorHolder = &mRustParser;
- mSdp = mozilla::Move(mRustParser.Parse(sdp));
+ mSdp = std::move(mRustParser.Parse(sdp));
}
// Are we configured to do a parse and serialize before actually
// running the test?
if (::testing::get<0>(GetParam())) {
std::stringstream os;
if (expectSuccess) {
ASSERT_TRUE(!!mSdp) << "Parse failed on first pass: "
<< GetParseErrors();
}
if (mSdp) {
// Serialize and re-parse
mSdp->Serialize(os);
if (::testing::get<1>(GetParam())) {
- mSdp = mozilla::Move(mSipccParser.Parse(os.str()));
+ mSdp = std::move(mSipccParser.Parse(os.str()));
} else {
- mSdp = mozilla::Move(mRustParser.Parse(os.str()));
+ mSdp = std::move(mRustParser.Parse(os.str()));
}
// Whether we expected the parse to work or not, it should
// succeed the second time if it succeeded the first.
ASSERT_TRUE(!!mSdp) << "Parse failed on second pass, SDP was: "
<< std::endl << os.str() << std::endl
<< "Errors were: " << GetParseErrors();
--- a/media/webrtc/signaling/src/common/PtrVector.h
+++ b/media/webrtc/signaling/src/common/PtrVector.h
@@ -15,17 +15,17 @@ namespace mozilla
// TODO: Remove this once our buildconfig allows us to put unique_ptr in stl
// containers, and just use std::vector<unique_ptr<T>> instead.
template <class T> class PtrVector
{
public:
PtrVector() = default;
PtrVector(const PtrVector&) = delete;
PtrVector(PtrVector&& aOther)
- : values(Move(aOther.values))
+ : values(std::move(aOther.values))
{}
PtrVector& operator=(const PtrVector&) = delete;
PtrVector& operator=(PtrVector&& aOther)
{
Swap(values, aOther.values);
return *this;
}
--- a/media/webrtc/signaling/src/jsep/JsepSessionImpl.cpp
+++ b/media/webrtc/signaling/src/jsep/JsepSessionImpl.cpp
@@ -453,17 +453,17 @@ JsepSessionImpl::CreateOffer(const JsepO
*mCurrentLocalDescription,
*sdp,
sdp.get());
NS_ENSURE_SUCCESS(rv,rv);
CopyPreviousMsid(*mCurrentLocalDescription, sdp.get());
}
*offer = sdp->ToString();
- mGeneratedLocalDescription = Move(sdp);
+ mGeneratedLocalDescription = std::move(sdp);
++mSessionVersion;
return NS_OK;
}
std::string
JsepSessionImpl::GetLocalDescription(JsepDescriptionPendingOrCurrent type) const
{
@@ -595,17 +595,17 @@ JsepSessionImpl::CreateAnswer(const Jsep
*mCurrentRemoteDescription,
offer,
sdp.get());
NS_ENSURE_SUCCESS(rv,rv);
CopyPreviousMsid(*mCurrentLocalDescription, sdp.get());
}
*answer = sdp->ToString();
- mGeneratedLocalDescription = Move(sdp);
+ mGeneratedLocalDescription = std::move(sdp);
++mSessionVersion;
return NS_OK;
}
nsresult
JsepSessionImpl::CreateAnswerMsection(const JsepAnswerOptions& options,
JsepTransceiver& transceiver,
@@ -784,51 +784,51 @@ JsepSessionImpl::SetLocalDescription(Jse
transceiver->Associate(
parsed->GetMediaSection(i).GetAttributeList().GetMid());
transceiver->mTransport = new JsepTransport;
InitTransport(parsed->GetMediaSection(i), transceiver->mTransport.get());
}
switch (type) {
case kJsepSdpOffer:
- rv = SetLocalDescriptionOffer(Move(parsed));
+ rv = SetLocalDescriptionOffer(std::move(parsed));
break;
case kJsepSdpAnswer:
case kJsepSdpPranswer:
- rv = SetLocalDescriptionAnswer(type, Move(parsed));
+ rv = SetLocalDescriptionAnswer(type, std::move(parsed));
break;
case kJsepSdpRollback:
MOZ_CRASH(); // Handled above
}
return rv;
}
nsresult
JsepSessionImpl::SetLocalDescriptionOffer(UniquePtr<Sdp> offer)
{
MOZ_ASSERT(mState == kJsepStateStable);
- mPendingLocalDescription = Move(offer);
+ mPendingLocalDescription = std::move(offer);
SetState(kJsepStateHaveLocalOffer);
return NS_OK;
}
nsresult
JsepSessionImpl::SetLocalDescriptionAnswer(JsepSdpType type,
UniquePtr<Sdp> answer)
{
MOZ_ASSERT(mState == kJsepStateHaveRemoteOffer);
- mPendingLocalDescription = Move(answer);
+ mPendingLocalDescription = std::move(answer);
nsresult rv = HandleNegotiatedSession(mPendingLocalDescription,
mPendingRemoteDescription);
NS_ENSURE_SUCCESS(rv, rv);
- mCurrentRemoteDescription = Move(mPendingRemoteDescription);
- mCurrentLocalDescription = Move(mPendingLocalDescription);
+ mCurrentRemoteDescription = std::move(mPendingRemoteDescription);
+ mCurrentLocalDescription = std::move(mPendingLocalDescription);
MOZ_ASSERT(!mIsOfferer);
mWasOffererLastTime = false;
SetState(kJsepStateStable);
return NS_OK;
}
nsresult
@@ -942,21 +942,21 @@ JsepSessionImpl::SetRemoteDescription(Js
NS_ENSURE_SUCCESS(rv, rv);
for (size_t i = 0; i < parsed->GetMediaSectionCount(); ++i) {
MOZ_ASSERT(GetTransceiverForLevel(i));
}
switch (type) {
case kJsepSdpOffer:
- rv = SetRemoteDescriptionOffer(Move(parsed));
+ rv = SetRemoteDescriptionOffer(std::move(parsed));
break;
case kJsepSdpAnswer:
case kJsepSdpPranswer:
- rv = SetRemoteDescriptionAnswer(type, Move(parsed));
+ rv = SetRemoteDescriptionAnswer(type, std::move(parsed));
break;
case kJsepSdpRollback:
MOZ_CRASH(); // Handled above
}
if (NS_SUCCEEDED(rv)) {
mRemoteIsIceLite = iceLite;
mIceOptions = iceOptions;
@@ -1194,18 +1194,18 @@ JsepSessionImpl::FinalizeTransport(const
: JsepDtlsTransport::kJsepDtlsClient;
} else {
dtls->mRole = (answer.GetSetup().mRole == SdpSetupAttribute::kActive)
? JsepDtlsTransport::kJsepDtlsClient
: JsepDtlsTransport::kJsepDtlsServer;
}
}
- transport->mIce = Move(ice);
- transport->mDtls = Move(dtls);
+ transport->mIce = std::move(ice);
+ transport->mDtls = std::move(dtls);
if (answer.HasAttribute(SdpAttribute::kRtcpMuxAttribute)) {
transport->mComponents = 1;
}
return NS_OK;
}
@@ -1373,46 +1373,46 @@ JsepSessionImpl::ParseSdp(const std::str
}
}
}
}
nsresult rv = RemoveDuplicateTrackIds(parsed.get());
NS_ENSURE_SUCCESS(rv, rv);
- *parsedp = Move(parsed);
+ *parsedp = std::move(parsed);
return NS_OK;
}
nsresult
JsepSessionImpl::SetRemoteDescriptionOffer(UniquePtr<Sdp> offer)
{
MOZ_ASSERT(mState == kJsepStateStable);
- mPendingRemoteDescription = Move(offer);
+ mPendingRemoteDescription = std::move(offer);
SetState(kJsepStateHaveRemoteOffer);
return NS_OK;
}
nsresult
JsepSessionImpl::SetRemoteDescriptionAnswer(JsepSdpType type,
UniquePtr<Sdp> answer)
{
MOZ_ASSERT(mState == kJsepStateHaveLocalOffer ||
mState == kJsepStateHaveRemotePranswer);
- mPendingRemoteDescription = Move(answer);
+ mPendingRemoteDescription = std::move(answer);
nsresult rv = HandleNegotiatedSession(mPendingLocalDescription,
mPendingRemoteDescription);
NS_ENSURE_SUCCESS(rv, rv);
- mCurrentRemoteDescription = Move(mPendingRemoteDescription);
- mCurrentLocalDescription = Move(mPendingLocalDescription);
+ mCurrentRemoteDescription = std::move(mPendingRemoteDescription);
+ mCurrentLocalDescription = std::move(mPendingLocalDescription);
MOZ_ASSERT(mIsOfferer);
mWasOffererLastTime = true;
SetState(kJsepStateStable);
return NS_OK;
}
JsepTransceiver*
@@ -1917,17 +1917,17 @@ JsepSessionImpl::CreateGenericSDP(Unique
sdp->GetAttributeList().SetAttribute(iceOpts);
// This assumes content doesn't add a bunch of msid attributes with a
// different semantic in mind.
std::vector<std::string> msids;
msids.push_back("*");
mSdpHelper.SetupMsidSemantic(msids, sdp.get());
- *sdpp = Move(sdp);
+ *sdpp = std::move(sdp);
return NS_OK;
}
nsresult
JsepSessionImpl::SetupIds()
{
SECStatus rv = PK11_GenerateRandom(
reinterpret_cast<unsigned char*>(&mSessionId), sizeof(mSessionId));
--- a/media/webrtc/signaling/src/jsep/JsepSessionImpl.h
+++ b/media/webrtc/signaling/src/jsep/JsepSessionImpl.h
@@ -37,17 +37,17 @@ public:
mWasOffererLastTime(false),
mIceControlling(false),
mLocalIceIsRestarting(false),
mRemoteIsIceLite(false),
mRemoteIceIsRestarting(false),
mBundlePolicy(kBundleBalanced),
mSessionId(0),
mSessionVersion(0),
- mUuidGen(Move(uuidgen)),
+ mUuidGen(std::move(uuidgen)),
mSdpHelper(&mLastError)
{
}
// Implement JsepSession methods.
virtual nsresult Init() override;
virtual nsresult SetIceCredentials(const std::string& ufrag,
--- a/media/webrtc/signaling/src/jsep/JsepTrack.cpp
+++ b/media/webrtc/signaling/src/jsep/JsepTrack.cpp
@@ -551,17 +551,17 @@ JsepTrack::Negotiate(const SdpMediaSecti
}
if (direction & mDirection) {
negotiatedDetails->mExtmap[extmapAttr.extensionname] = extmapAttr;
}
}
}
- mNegotiatedDetails = Move(negotiatedDetails);
+ mNegotiatedDetails = std::move(negotiatedDetails);
}
// When doing bundle, if all else fails we can try to figure out which m-line a
// given RTP packet belongs to by looking at the payload type field. This only
// works, however, if that payload type appeared in only one m-section.
// We figure that out here.
/* static */
void
--- a/media/webrtc/signaling/src/media-conduit/VideoConduit.cpp
+++ b/media/webrtc/signaling/src/media-conduit/VideoConduit.cpp
@@ -1995,24 +1995,24 @@ WebrtcVideoConduit::ReceivedRTPPacket(co
// dispatches back to us, it's less critial to do this here, but doesn't
// hurt.
UniquePtr<QueuedPacket> packet((QueuedPacket*) malloc(sizeof(QueuedPacket) + len-1));
packet->mLen = len;
memcpy(packet->mData, data, len);
CSFLogDebug(LOGTAG, "queuing packet: seq# %u, Len %d ",
(uint16_t)ntohs(((uint16_t*) packet->mData)[1]), packet->mLen);
if (queue) {
- mQueuedPackets.AppendElement(Move(packet));
+ mQueuedPackets.AppendElement(std::move(packet));
return kMediaConduitNoError;
}
// a new switch needs to be done
// any queued packets are from a previous switch that hasn't completed
// yet; drop them and only process the latest SSRC
mQueuedPackets.Clear();
- mQueuedPackets.AppendElement(Move(packet));
+ mQueuedPackets.AppendElement(std::move(packet));
CSFLogDebug(LOGTAG, "%s: switching from SSRC %u to %u", __FUNCTION__,
mRecvSSRC, ssrc);
// we "switch" here immediately, but buffer until the queue is released
mRecvSSRC = ssrc;
mRecvSSRCSetInProgress = true;
queue = true;
--- a/media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.cpp
+++ b/media/webrtc/signaling/src/media-conduit/WebrtcGmpVideoCodec.cpp
@@ -214,17 +214,17 @@ WebrtcGmpVideoEncoder::InitEncode_g(
nsTArray<nsCString> tags;
tags.AppendElement(NS_LITERAL_CSTRING("h264"));
UniquePtr<GetGMPVideoEncoderCallback> callback(
new InitDoneCallback(aThis, aInitDone, aCodecParams, aMaxPayloadSize));
aThis->mInitting = true;
nsresult rv = aThis->mMPS->GetGMPVideoEncoder(nullptr,
&tags,
NS_LITERAL_CSTRING(""),
- Move(callback));
+ std::move(callback));
if (NS_WARN_IF(NS_FAILED(rv))) {
LOGD(("GMP Encode: GetGMPVideoEncoder failed"));
aThis->Close_g();
aInitDone->Dispatch(WEBRTC_VIDEO_CODEC_ERROR,
"GMP Encode: GetGMPVideoEncoder failed");
}
}
@@ -348,17 +348,17 @@ WebrtcGmpVideoEncoder::RegetEncoderForRe
// re-init the plugin when the resolution changes
// XXX allow codec to indicate it doesn't need re-init!
nsTArray<nsCString> tags;
tags.AppendElement(NS_LITERAL_CSTRING("h264"));
mInitting = true;
if (NS_WARN_IF(NS_FAILED(mMPS->GetGMPVideoEncoder(nullptr,
&tags,
NS_LITERAL_CSTRING(""),
- Move(callback))))) {
+ std::move(callback))))) {
aInitDone->Dispatch(WEBRTC_VIDEO_CODEC_ERROR,
"GMP Encode: GetGMPVideoEncoder failed");
}
}
void
WebrtcGmpVideoEncoder::Encode_g(RefPtr<WebrtcGmpVideoEncoder>& aEncoder,
webrtc::VideoFrame aInputImage,
@@ -433,17 +433,17 @@ WebrtcGmpVideoEncoder::Encode_g(RefPtr<W
LOGD(("GMP Encode: failed to map webrtc frame type to gmp frame type"));
return;
}
gmp_frame_types.AppendElement(ft);
}
LOGD(("GMP Encode: %llu", (aInputImage.timestamp() * 1000ll)/90));
- err = aEncoder->mGMP->Encode(Move(frame), codecSpecificInfo, gmp_frame_types);
+ err = aEncoder->mGMP->Encode(std::move(frame), codecSpecificInfo, gmp_frame_types);
if (err != GMPNoErr) {
LOGD(("GMP Encode: failed to encode frame"));
}
}
int32_t
WebrtcGmpVideoEncoder::RegisterEncodeCompleteCallback(webrtc::EncodedImageCallback* aCallback)
{
@@ -709,17 +709,17 @@ WebrtcGmpVideoDecoder::InitDecode_g(
nsTArray<nsCString> tags;
tags.AppendElement(NS_LITERAL_CSTRING("h264"));
UniquePtr<GetGMPVideoDecoderCallback> callback(
new InitDoneCallback(aThis, aInitDone));
aThis->mInitting = true;
nsresult rv = aThis->mMPS->GetGMPVideoDecoder(nullptr,
&tags,
NS_LITERAL_CSTRING(""),
- Move(callback));
+ std::move(callback));
if (NS_WARN_IF(NS_FAILED(rv))) {
LOGD(("GMP Decode: GetGMPVideoDecoder failed"));
aThis->Close_g();
aInitDone->Dispatch(WEBRTC_VIDEO_CODEC_ERROR,
"GMP Decode: GetGMPVideoDecoder failed.");
}
}
@@ -880,17 +880,17 @@ WebrtcGmpVideoDecoder::Decode_g(const Re
info.mCodecType = kGMPVideoCodecH264;
info.mCodecSpecific.mH264.mSimulcastIdx = 0;
nsTArray<uint8_t> codecSpecificInfo;
codecSpecificInfo.AppendElements((uint8_t*)&info, sizeof(GMPCodecSpecificInfo));
LOGD(("GMP Decode: %" PRIu64 ", len %zu%s", frame->TimeStamp(),
aDecodeData->mImage._length, ft == kGMPKeyFrame ? ", KeyFrame" : ""));
- nsresult rv = aThis->mGMP->Decode(Move(frame),
+ nsresult rv = aThis->mGMP->Decode(std::move(frame),
aDecodeData->mMissingFrames,
codecSpecificInfo,
aDecodeData->mRenderTimeMs);
if (NS_FAILED(rv)) {
LOG(LogLevel::Error, ("%s: Decode failed (rv=%u)!",
__PRETTY_FUNCTION__, static_cast<unsigned>(rv)));
}
--- a/media/webrtc/signaling/src/media-conduit/WebrtcMediaDataDecoderCodec.cpp
+++ b/media/webrtc/signaling/src/media-conduit/WebrtcMediaDataDecoderCodec.cpp
@@ -128,17 +128,17 @@ WebrtcMediaDataDecoder::Decode(
MOZ_ASSERT(frame->mType == MediaData::VIDEO_DATA);
RefPtr<VideoData> video = frame->As<VideoData>();
MOZ_ASSERT(video);
if (!video->mImage) {
// Nothing to display.
continue;
}
rtc::scoped_refptr<ImageBuffer> image(
- new rtc::RefCountedObject<ImageBuffer>(Move(video->mImage)));
+ new rtc::RefCountedObject<ImageBuffer>(std::move(video->mImage)));
webrtc::VideoFrame videoFrame(image,
frame->mTime.ToMicroseconds(),
frame->mDuration.ToMicroseconds() * 1000,
aInputImage.rotation_);
mCallback->Decoded(videoFrame);
}
mResults.Clear();
@@ -176,17 +176,17 @@ WebrtcMediaDataDecoder::OnTaskQueue() co
{
return OwnerThread()->IsCurrentThreadIn();
}
ImageBuffer::ImageBuffer(RefPtr<layers::Image>&& aImage)
: webrtc::NativeHandleBuffer(aImage,
aImage->GetSize().width,
aImage->GetSize().height)
- , mImage(Move(aImage))
+ , mImage(std::move(aImage))
{
}
rtc::scoped_refptr<webrtc::VideoFrameBuffer>
ImageBuffer::NativeToI420Buffer()
{
RefPtr<layers::PlanarYCbCrImage> image = mImage->AsPlanarYCbCrImage();
if (!image) {
--- a/media/webrtc/signaling/src/peerconnection/PacketDumper.cpp
+++ b/media/webrtc/signaling/src/peerconnection/PacketDumper.cpp
@@ -53,15 +53,15 @@ PacketDumper::Dump(size_t level, dom::mo
media::NewRunnableFrom(
std::bind(
[pc, level, type, sending, size](UniquePtr<uint8_t[]>& packet)
-> nsresult
{
pc->DumpPacket_m(level, type, sending, packet, size);
return NS_OK;
},
- Move(ownedPacket)));
+ std::move(ownedPacket)));
NS_DispatchToMainThread(dumpRunnable);
}
} //namespace mozilla
--- a/media/webrtc/signaling/src/sdp/RsdparsaSdp.cpp
+++ b/media/webrtc/signaling/src/sdp/RsdparsaSdp.cpp
@@ -18,35 +18,35 @@
#undef CRLF
#endif
#define CRLF "\r\n"
namespace mozilla
{
RsdparsaSdp::RsdparsaSdp(RsdparsaSessionHandle session, const SdpOrigin& origin)
- : mSession(Move(session))
+ : mSession(std::move(session))
, mOrigin(origin)
{
RsdparsaSessionHandle attributeSession(sdp_new_reference(mSession.get()));
- mAttributeList.reset(new RsdparsaSdpAttributeList(Move(attributeSession)));
+ mAttributeList.reset(new RsdparsaSdpAttributeList(std::move(attributeSession)));
size_t section_count = sdp_media_section_count(mSession.get());
for (size_t level = 0; level < section_count; level++) {
RustMediaSection* mediaSection = sdp_get_media_section(mSession.get(),
level);
if (!mediaSection) {
MOZ_ASSERT(false, "sdp_get_media_section failed because level was out of"
" bounds, but we did a bounds check!");
break;
}
RsdparsaSessionHandle newSession(sdp_new_reference(mSession.get()));
RsdparsaSdpMediaSection* sdpMediaSection;
sdpMediaSection = new RsdparsaSdpMediaSection(level,
- Move(newSession),
+ std::move(newSession),
mediaSection,
mAttributeList.get());
mMediaSections.values.push_back(sdpMediaSection);
}
}
const SdpOrigin&
RsdparsaSdp::GetOrigin() const
--- a/media/webrtc/signaling/src/sdp/RsdparsaSdpAttributeList.h
+++ b/media/webrtc/signaling/src/sdp/RsdparsaSdpAttributeList.h
@@ -77,29 +77,29 @@ public:
SdpDirectionAttribute::Direction GetDirection() const override;
void Serialize(std::ostream&) const override;
virtual ~RsdparsaSdpAttributeList();
private:
explicit RsdparsaSdpAttributeList(RsdparsaSessionHandle session)
- : mSession(Move(session))
+ : mSession(std::move(session))
, mSessionAttributes(nullptr)
, mIsVideo(false)
, mAttributes()
{
RustAttributeList* attributes = get_sdp_session_attributes(mSession.get());
LoadAll(attributes);
}
RsdparsaSdpAttributeList(RsdparsaSessionHandle session,
const RustMediaSection* const msection,
const RsdparsaSdpAttributeList* sessionAttributes)
- : mSession(Move(session))
+ : mSession(std::move(session))
, mSessionAttributes(sessionAttributes)
, mAttributes()
{
mIsVideo = sdp_rust_get_media_type(msection) == RustSdpMediaValue::kRustVideo;
RustAttributeList* attributes = sdp_get_media_attribute_list(msection);
LoadAll(attributes);
}
--- a/media/webrtc/signaling/src/sdp/RsdparsaSdpMediaSection.cpp
+++ b/media/webrtc/signaling/src/sdp/RsdparsaSdpMediaSection.cpp
@@ -21,33 +21,33 @@
#define CRLF "\r\n"
namespace mozilla
{
RsdparsaSdpMediaSection::RsdparsaSdpMediaSection(size_t level,
RsdparsaSessionHandle session, const RustMediaSection* const section,
const RsdparsaSdpAttributeList* sessionLevel)
- : SdpMediaSection(level), mSession(Move(session)),
+ : SdpMediaSection(level), mSession(std::move(session)),
mSection(section)
{
switch(sdp_rust_get_media_type(section)) {
case RustSdpMediaValue::kRustAudio:
mMediaType = kAudio;
break;
case RustSdpMediaValue::kRustVideo:
mMediaType = kVideo;
break;
case RustSdpMediaValue::kRustApplication:
mMediaType = kApplication;
break;
}
RsdparsaSessionHandle attributeSession(sdp_new_reference(mSession.get()));
- mAttributeList.reset(new RsdparsaSdpAttributeList(Move(attributeSession),
+ mAttributeList.reset(new RsdparsaSdpAttributeList(std::move(attributeSession),
section,
sessionLevel));
LoadFormats();
LoadConnection();
}
unsigned int
--- a/media/webrtc/signaling/src/sdp/RsdparsaSdpParser.cpp
+++ b/media/webrtc/signaling/src/sdp/RsdparsaSdpParser.cpp
@@ -42,12 +42,12 @@ RsdparsaSdpParser::Parse(const std::stri
}
RsdparsaSessionHandle uniqueResult;
uniqueResult.reset(result);
RustSdpOrigin rustOrigin = sdp_get_origin(uniqueResult.get());
sdp::AddrType addrType = convertAddressType(rustOrigin.addr.addrType);
SdpOrigin origin(convertStringView(rustOrigin.username),
rustOrigin.sessionId, rustOrigin.sessionVersion,
addrType, std::string(rustOrigin.addr.unicastAddr));
- return MakeUnique<RsdparsaSdp>(Move(uniqueResult), origin);
+ return MakeUnique<RsdparsaSdp>(std::move(uniqueResult), origin);
}
} // namespace mozilla
--- a/media/webrtc/signaling/src/sdp/SdpAttribute.h
+++ b/media/webrtc/signaling/src/sdp/SdpAttribute.h
@@ -1439,17 +1439,17 @@ public:
std::string dtmfTones;
};
class Fmtp
{
public:
Fmtp(const std::string& aFormat, UniquePtr<Parameters> aParameters)
: format(aFormat),
- parameters(Move(aParameters))
+ parameters(std::move(aParameters))
{
}
Fmtp(const std::string& aFormat, const Parameters& aParameters)
: format(aFormat),
parameters(aParameters.Clone())
{
}
@@ -1477,17 +1477,17 @@ public:
UniquePtr<Parameters> parameters;
};
virtual void Serialize(std::ostream& os) const override;
void
PushEntry(const std::string& format, UniquePtr<Parameters> parameters)
{
- mFmtps.push_back(Fmtp(format, Move(parameters)));
+ mFmtps.push_back(Fmtp(format, std::move(parameters)));
}
std::vector<Fmtp> mFmtps;
};
///////////////////////////////////////////////////////////////////////////
// a=sctpmap, draft-ietf-mmusic-sctp-sdp-05
//-------------------------------------------------------------------------
--- a/media/webrtc/signaling/src/sdp/SipccSdpAttributeList.cpp
+++ b/media/webrtc/signaling/src/sdp/SipccSdpAttributeList.cpp
@@ -781,17 +781,17 @@ SipccSdpAttributeList::LoadFmtp(sdp_t* s
teParameters->dtmfTones = fmtp->dtmf_tones;
}
parameters.reset(teParameters);
} break;
default: {
}
}
- fmtps->PushEntry(osPayloadType.str(), Move(parameters));
+ fmtps->PushEntry(osPayloadType.str(), std::move(parameters));
}
if (!fmtps->mFmtps.empty()) {
SetAttribute(fmtps.release());
}
}
void
--- a/media/webrtc/signaling/src/sdp/SipccSdpParser.cpp
+++ b/media/webrtc/signaling/src/sdp/SipccSdpParser.cpp
@@ -74,12 +74,12 @@ SipccSdpParser::Parse(const std::string
UniquePtr<SipccSdp> sipccSdp(new SipccSdp);
bool success = sipccSdp->Load(sdp, *this);
sdp_free_description(sdp);
if (!success) {
return UniquePtr<Sdp>();
}
- return UniquePtr<Sdp>(Move(sipccSdp));
+ return UniquePtr<Sdp>(std::move(sipccSdp));
}
} // namespace mozilla
--- a/memory/replace/dmd/DMD.cpp
+++ b/memory/replace/dmd/DMD.cpp
@@ -1812,17 +1812,17 @@ AnalyzeImpl(UniquePtr<JSONWriteFunc> aWr
{
// Some blocks may have been allocated while creating |aWriter|. Those blocks
// will be freed at the end of this function when |write| is destroyed. The
// allocations will have occurred while intercepts were not blocked, so the
// frees better be as well, otherwise we'll get assertion failures.
// Therefore, this declaration must precede the AutoBlockIntercepts
// declaration, to ensure that |write| is destroyed *after* intercepts are
// unblocked.
- JSONWriter writer(Move(aWriter));
+ JSONWriter writer(std::move(aWriter));
AutoBlockIntercepts block(Thread::Fetch());
AutoLockState lock;
// Allocate this on the heap instead of the stack because it's fairly large.
auto locService = InfallibleAllocPolicy::new_<CodeAddressService>();
StackTraceSet usedStackTraces;
@@ -2073,17 +2073,17 @@ AnalyzeImpl(UniquePtr<JSONWriteFunc> aWr
InfallibleAllocPolicy::delete_(locService);
StatusMsg("}\n");
}
void
DMDFuncs::Analyze(UniquePtr<JSONWriteFunc> aWriter)
{
- AnalyzeImpl(Move(aWriter));
+ AnalyzeImpl(std::move(aWriter));
ClearReports();
}
//---------------------------------------------------------------------------
// Testing
//---------------------------------------------------------------------------
void
--- a/memory/replace/dmd/DMD.h
+++ b/memory/replace/dmd/DMD.h
@@ -251,17 +251,17 @@ ClearReports()
// -Werror for various reasons.
//
template <typename JSONWriteFunc>
inline void
Analyze(UniquePtr<JSONWriteFunc> aWriteFunc)
{
DMDFuncs* funcs = DMDFuncs::Get();
if (funcs) {
- funcs->Analyze(Move(aWriteFunc));
+ funcs->Analyze(std::move(aWriteFunc));
}
}
// Gets the size of various data structures. Used to implement a memory
// reporter for DMD.
inline void
SizeOf(Sizes* aSizes)
{
--- a/memory/replace/dmd/test/SmokeDMD.cpp
+++ b/memory/replace/dmd/test/SmokeDMD.cpp
@@ -97,17 +97,17 @@ TestEmpty(const char* aTestName, const c
sprintf(filename, "complete-%s-%s.json", aTestName, aMode);
auto f = MakeUnique<FpWriteFunc>(filename);
char options[128];
sprintf(options, "--mode=%s --stacks=full", aMode);
ResetEverything(options);
// Zero for everything.
- Analyze(Move(f));
+ Analyze(std::move(f));
}
void
TestFull(const char* aTestName, int aNum, const char* aMode, int aSeven)
{
char filename[128];
sprintf(filename, "complete-%s%d-%s.json", aTestName, aNum, aMode);
auto f = MakeUnique<FpWriteFunc>(filename);
@@ -240,17 +240,17 @@ TestFull(const char* aTestName, int aNum
//UseItOrLoseIt(y, aSeven);
// XXX: C11 only
//void* z = aligned_alloc(64, 256);
//UseItOrLoseIt(z, aSeven);
if (aNum == 1) {
// Analyze 1.
- Analyze(Move(f));
+ Analyze(std::move(f));
}
ClearReports();
//---------
Report(a2);
Report(a2);
@@ -267,17 +267,17 @@ TestFull(const char* aTestName, int aNum
for (int i = 0; i < 100; i++) {
void* v = malloc(128);
UseItOrLoseIt(v, aSeven);
free(v);
}
if (aNum == 2) {
// Analyze 2.
- Analyze(Move(f));
+ Analyze(std::move(f));
}
}
void
TestPartial(const char* aTestName, const char* aMode, int aSeven)
{
char filename[128];
sprintf(filename, "complete-%s-%s.json", aTestName, aMode);
@@ -313,17 +313,17 @@ TestPartial(const char* aTestName, const
// Expected fraction with stacks: (1 - (1 - 0.003) ** 1024) = 0.9539.
// So we expect about 0.9539 * 10000 == 9539.
// We actually get 9531.
for (int i = 0; i < kTenThousand; i++) {
s = (char*) malloc(1024);
UseItOrLoseIt(s, aSeven);
}
- Analyze(Move(f));
+ Analyze(std::move(f));
}
void
TestScan(int aSeven)
{
auto f = MakeUnique<FpWriteFunc>("basic-scan.json");
ResetEverything("--mode=scan");
@@ -334,17 +334,17 @@ TestScan(int aSeven)
// Hard-coded values checked by scan-test.py
p[0] = 0x123; // outside a block, small value
p[1] = 0x0; // null
p[2] = (uintptr_t)((uint8_t*)p - 1); // pointer outside a block, but nearby
p[3] = (uintptr_t)p; // pointer to start of a block
p[4] = (uintptr_t)((uint8_t*)p + 1); // pointer into a block
p[5] = 0x0; // trailing null
- Analyze(Move(f));
+ Analyze(std::move(f));
}
void
RunTests()
{
// This test relies on the compiler not doing various optimizations, such as
// eliding unused malloc() calls or unrolling loops with fixed iteration
// counts. So we compile it with -O0 (or equivalent), which probably prevents
--- a/mfbt/AlreadyAddRefed.h
+++ b/mfbt/AlreadyAddRefed.h
@@ -29,17 +29,17 @@ struct unused_t;
* because of the sheer number of usages of already_AddRefed.
*
* When should you use already_AddRefed<>?
* * Ensure a consumer takes ownership of a reference
* * Pass ownership without calling AddRef/Release (sometimes required in
* off-main-thread code)
* * The ref pointer type you're using doesn't support move construction
*
- * Otherwise, use Move(RefPtr/nsCOMPtr/etc).
+ * Otherwise, use std::move(RefPtr/nsCOMPtr/etc).
*/
template<class T>
struct MOZ_TEMPORARY_CLASS MOZ_MUST_USE_TYPE MOZ_NON_AUTOABLE already_AddRefed
{
/*
* We want to allow returning nullptr from functions returning
* already_AddRefed<T>, for simplicity. But we also don't want to allow
* returning raw T*, instead preferring creation of already_AddRefed<T> from
--- a/mfbt/BufferList.h
+++ b/mfbt/BufferList.h
@@ -95,32 +95,32 @@ class BufferList : private AllocPolicy
AllocateSegment(aInitialSize, aInitialCapacity);
}
}
BufferList(const BufferList& aOther) = delete;
BufferList(BufferList&& aOther)
: mOwning(aOther.mOwning),
- mSegments(Move(aOther.mSegments)),
+ mSegments(std::move(aOther.mSegments)),
mSize(aOther.mSize),
mStandardCapacity(aOther.mStandardCapacity)
{
aOther.mSegments.clear();
aOther.mSize = 0;
}
BufferList& operator=(const BufferList& aOther) = delete;
BufferList& operator=(BufferList&& aOther)
{
Clear();
mOwning = aOther.mOwning;
- mSegments = Move(aOther.mSegments);
+ mSegments = std::move(aOther.mSegments);
mSize = aOther.mSize;
aOther.mSegments.clear();
aOther.mSize = 0;
return *this;
}
~BufferList() { Clear(); }
--- a/mfbt/EnumeratedArray.h
+++ b/mfbt/EnumeratedArray.h
@@ -64,34 +64,34 @@ public:
for (size_t i = 0; i < kSize; i++) {
mArray[i] = aOther.mArray[i];
}
}
EnumeratedArray(EnumeratedArray&& aOther)
{
for (size_t i = 0; i < kSize; i++) {
- mArray[i] = Move(aOther.mArray[i]);
+ mArray[i] = std::move(aOther.mArray[i]);
}
}
ValueType& operator[](IndexType aIndex)
{
return mArray[size_t(aIndex)];
}
const ValueType& operator[](IndexType aIndex) const
{
return mArray[size_t(aIndex)];
}
EnumeratedArray& operator =(EnumeratedArray&& aOther)
{
for (size_t i = 0; i < kSize; i++) {
- mArray[i] = Move(aOther.mArray[i]);
+ mArray[i] = std::move(aOther.mArray[i]);
}
return *this;
}
typedef typename ArrayType::iterator iterator;
typedef typename ArrayType::const_iterator const_iterator;
typedef typename ArrayType::reverse_iterator reverse_iterator;
typedef typename ArrayType::const_reverse_iterator const_reverse_iterator;
--- a/mfbt/GuardObjects.h
+++ b/mfbt/GuardObjects.h
@@ -141,19 +141,19 @@ public:
# define MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM \
::mozilla::detail::GuardObjectNotifier&& _notifier = \
::mozilla::detail::GuardObjectNotifier()
# define MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL \
, ::mozilla::detail::GuardObjectNotifier&& _notifier
# define MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_IN_IMPL \
::mozilla::detail::GuardObjectNotifier&& _notifier
# define MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT \
- , ::mozilla::Move(_notifier)
+ , ::std::move(_notifier)
# define MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_TO_PARENT \
- ::mozilla::Move(_notifier)
+ ::std::move(_notifier)
# define MOZ_GUARD_OBJECT_NOTIFIER_INIT \
do { _mCheckNotUsedAsTemporary.init(_notifier); } while (0)
#else
# define MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
# define MOZ_GUARD_OBJECT_NOTIFIER_PARAM
# define MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM
# define MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL
# define MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_IN_IMPL
--- a/mfbt/JSONWriter.h
+++ b/mfbt/JSONWriter.h
@@ -335,17 +335,17 @@ protected:
} else {
mDepth--;
}
mWriter->Write(aEndChar);
}
public:
explicit JSONWriter(UniquePtr<JSONWriteFunc> aWriter)
- : mWriter(Move(aWriter))
+ : mWriter(std::move(aWriter))
, mNeedComma()
, mNeedNewlines()
, mDepth(0)
{
NewVectorEntries();
}
// Returns the JSONWriteFunc passed in at creation, for temporary use. The
--- a/mfbt/LinkedList.h
+++ b/mfbt/LinkedList.h
@@ -175,25 +175,25 @@ public:
/*
* Moves |aOther| into |*this|. If |aOther| is already in a list, then
* |aOther| is removed from the list and replaced by |*this|.
*/
LinkedListElement(LinkedListElement<T>&& aOther)
: mIsSentinel(aOther.mIsSentinel)
{
- adjustLinkForMove(Move(aOther));
+ adjustLinkForMove(std::move(aOther));
}
LinkedListElement& operator=(LinkedListElement<T>&& aOther)
{
MOZ_ASSERT(mIsSentinel == aOther.mIsSentinel, "Mismatch NodeKind!");
MOZ_ASSERT(!isInList(),
"Assigning to an element in a list messes up that list!");
- adjustLinkForMove(Move(aOther));
+ adjustLinkForMove(std::move(aOther));
return *this;
}
~LinkedListElement()
{
if (!mIsSentinel && isInList()) {
remove();
}
@@ -434,23 +434,23 @@ public:
bool operator!=(const Iterator<Type>& aOther) const {
return mCurrent != aOther.mCurrent;
}
};
LinkedList() : sentinel(LinkedListElement<T>::NodeKind::Sentinel) { }
LinkedList(LinkedList<T>&& aOther)
- : sentinel(mozilla::Move(aOther.sentinel))
+ : sentinel(std::move(aOther.sentinel))
{ }
LinkedList& operator=(LinkedList<T>&& aOther)
{
MOZ_ASSERT(isEmpty(), "Assigning to a non-empty list leaks elements in that list!");
- sentinel = mozilla::Move(aOther.sentinel);
+ sentinel = std::move(aOther.sentinel);
return *this;
}
~LinkedList() {
MOZ_ASSERT(isEmpty(),
"failing this assertion means this LinkedList's creator is "
"buggy: it should have removed all this list's elements before "
"the list's destruction");
--- a/mfbt/Maybe.h
+++ b/mfbt/Maybe.h
@@ -213,33 +213,33 @@ public:
emplace(*aOther);
}
}
Maybe(Maybe&& aOther)
: mIsSome(false)
{
if (aOther.mIsSome) {
- emplace(Move(*aOther));
+ emplace(std::move(*aOther));
aOther.reset();
}
}
/**
* Maybe<T> can be move-constructed from a Maybe<U> if U is convertible to T.
*/
template<typename U,
typename =
typename std::enable_if<std::is_convertible<U, T>::value>::type>
MOZ_IMPLICIT
Maybe(Maybe<U>&& aOther)
: mIsSome(false)
{
if (aOther.isSome()) {
- emplace(Move(*aOther));
+ emplace(std::move(*aOther));
aOther.reset();
}
}
Maybe& operator=(const Maybe& aOther)
{
if (&aOther != this) {
if (aOther.mIsSome) {
@@ -273,38 +273,38 @@ public:
}
Maybe& operator=(Maybe&& aOther)
{
MOZ_ASSERT(this != &aOther, "Self-moves are prohibited");
if (aOther.mIsSome) {
if (mIsSome) {
- ref() = Move(aOther.ref());
+ ref() = std::move(aOther.ref());
} else {
- emplace(Move(*aOther));
+ emplace(std::move(*aOther));
}
aOther.reset();
} else {
reset();
}
return *this;
}
template<typename U,
typename =
typename std::enable_if<std::is_convertible<U, T>::value>::type>
Maybe& operator=(Maybe<U>&& aOther)
{
if (aOther.isSome()) {
if (mIsSome) {
- ref() = Move(aOther.ref());
+ ref() = std::move(aOther.ref());
} else {
- emplace(Move(*aOther));
+ emplace(std::move(*aOther));
}
aOther.reset();
} else {
reset();
}
return *this;
}
--- a/mfbt/MaybeOneOf.h
+++ b/mfbt/MaybeOneOf.h
@@ -73,31 +73,31 @@ public:
MaybeOneOf() : state(None) {}
~MaybeOneOf() { destroyIfConstructed(); }
MaybeOneOf(MaybeOneOf&& rhs)
: state(None)
{
if (!rhs.empty()) {
if (rhs.constructed<T1>()) {
- construct<T1>(Move(rhs.as<T1>()));
+ construct<T1>(std::move(rhs.as<T1>()));
rhs.as<T1>().~T1();
} else {
- construct<T2>(Move(rhs.as<T2>()));
+ construct<T2>(std::move(rhs.as<T2>()));
rhs.as<T2>().~T2();
}
rhs.state = None;
}
}
MaybeOneOf& operator=(MaybeOneOf&& rhs)
{
MOZ_ASSERT(this != &rhs, "Self-move is prohibited");
this->~MaybeOneOf();
- new(this) MaybeOneOf(Move(rhs));
+ new(this) MaybeOneOf(std::move(rhs));
return *this;
}
bool empty() const { return state == None; }
template <class T>
bool constructed() const { return state == Type2State<T>::result; }
--- a/mfbt/Move.h
+++ b/mfbt/Move.h
@@ -55,19 +55,19 @@ namespace mozilla {
*
* If a constructor has a single argument of type 'T&&' (an 'rvalue reference
* to T'), that indicates that it is a 'move constructor'. That's 1). It should
* move, not copy, its argument into the object being constructed. It may leave
* the original in any safely-destructible state.
*
* If a constructor's argument is an rvalue, as in 'C(f(x))' or 'C(x + y)', as
* opposed to an lvalue, as in 'C(x)', then overload resolution will prefer the
- * move constructor, if there is one. The 'mozilla::Move' function, defined in
+ * move constructor, if there is one. The 'std::move' function, defined in
* this file, is an identity function you can use in a constructor invocation to
- * make any argument into an rvalue, like this: C(Move(x)). That's 2). (You
+ * make any argument into an rvalue, like this: C(std::move(x)). That's 2). (You
* could use any function that works, but 'Move' indicates your intention
* clearly.)
*
* Where we might define a copy constructor for a class C like this:
*
* C(const C& rhs) { ... copy rhs to this ... }
*
* we would declare a move constructor like this:
@@ -75,40 +75,40 @@ namespace mozilla {
* C(C&& rhs) { .. move rhs to this ... }
*
* And where we might perform a copy like this:
*
* C c2(c1);
*
* we would perform a move like this:
*
- * C c2(Move(c1));
+ * C c2(std::move(c1));
*
* Note that 'T&&' implicitly converts to 'T&'. So you can pass a 'T&&' to an
* ordinary copy constructor for a type that doesn't support a special move
* constructor, and you'll just get a copy. This means that templates can use
* Move whenever they know they won't use the original value any more, even if
* they're not sure whether the type at hand has a specialized move constructor.
* If it doesn't, the 'T&&' will just convert to a 'T&', and the ordinary copy
* constructor will apply.
*
* A class with a move constructor can also provide a move assignment operator.
* A generic definition would run this's destructor, and then apply the move
* constructor to *this's memory. A typical definition:
*
* C& operator=(C&& rhs) {
* MOZ_ASSERT(&rhs != this, "self-moves are prohibited");
* this->~C();
- * new(this) C(Move(rhs));
+ * new(this) C(std::move(rhs));
* return *this;
* }
*
* With that in place, one can write move assignments like this:
*
- * c2 = Move(c1);
+ * c2 = std::move(c1);
*
* This destroys c2, moves c1's value to c2, and leaves c1 in an undefined but
* destructible state.
*
* As we say, a move must leave the original in a "destructible" state. The
* original's destructor will still be called, so if a move doesn't
* actually steal all its resources, that's fine. We require only that the
* move destination must take on the original's value; and that destructing
@@ -121,19 +121,19 @@ namespace mozilla {
* Forwarding:
*
* Sometimes we want copy construction or assignment if we're passed an ordinary
* value, but move construction if passed an rvalue reference. For example, if
* our constructor takes two arguments and either could usefully be a move, it
* seems silly to write out all four combinations:
*
* C::C(X& x, Y& y) : x(x), y(y) { }
- * C::C(X& x, Y&& y) : x(x), y(Move(y)) { }
- * C::C(X&& x, Y& y) : x(Move(x)), y(y) { }
- * C::C(X&& x, Y&& y) : x(Move(x)), y(Move(y)) { }
+ * C::C(X& x, Y&& y) : x(x), y(std::move(y)) { }
+ * C::C(X&& x, Y& y) : x(std::move(x)), y(y) { }
+ * C::C(X&& x, Y&& y) : x(std::move(x)), y(std::move(y)) { }
*
* To avoid this, C++11 has tweaks to make it possible to write what you mean.
* The four constructor overloads above can be written as one constructor
* template like so[0]:
*
* template <typename XArg, typename YArg>
* C::C(XArg&& x, YArg&& y) : x(Forward<XArg>(x)), y(Forward<YArg>(y)) { }
*
@@ -223,16 +223,16 @@ Forward(typename RemoveReference<T>::Typ
return static_cast<T&&>(aX);
}
/** Swap |aX| and |aY| using move-construction if possible. */
template<typename T>
inline void
Swap(T& aX, T& aY)
{
- T tmp(Move(aX));
- aX = Move(aY);
- aY = Move(tmp);
+ T tmp(std::move(aX));
+ aX = std::move(aY);
+ aY = std::move(tmp);
}
} // namespace mozilla
#endif /* mozilla_Move_h */
--- a/mfbt/Pair.h
+++ b/mfbt/Pair.h
@@ -156,27 +156,27 @@ struct Pair
public:
template<typename AArg, typename BArg>
Pair(AArg&& aA, BArg&& aB)
: Base(Forward<AArg>(aA), Forward<BArg>(aB))
{}
Pair(Pair&& aOther)
- : Base(Move(aOther.first()), Move(aOther.second()))
+ : Base(std::move(aOther.first()), std::move(aOther.second()))
{ }
Pair(const Pair& aOther) = default;
Pair& operator=(Pair&& aOther)
{
MOZ_ASSERT(this != &aOther, "Self-moves are prohibited");
- first() = Move(aOther.first());
- second() = Move(aOther.second());
+ first() = std::move(aOther.first());
+ second() = std::move(aOther.second());
return *this;
}
Pair& operator=(const Pair& aOther) = default;
/** The A instance. */
using Base::first;
--- a/mfbt/Saturate.h
+++ b/mfbt/Saturate.h
@@ -131,17 +131,17 @@ template <typename T>
class Saturate
{
public:
Saturate() = default;
MOZ_IMPLICIT Saturate(const Saturate<T>&) = default;
MOZ_IMPLICIT Saturate(Saturate<T>&& aValue)
{
- mValue = Move(aValue.mValue);
+ mValue = std::move(aValue.mValue);
}
explicit Saturate(const T& aValue)
: mValue(aValue)
{ }
const T& value() const
{
@@ -171,17 +171,17 @@ public:
}
// Assignment operators
Saturate<T>& operator=(const Saturate<T>&) = default;
Saturate<T>& operator=(Saturate<T>&& aRhs)
{
- mValue = Move(aRhs.mValue);
+ mValue = std::move(aRhs.mValue);
return *this;
}
// Add and subtract operators
Saturate<T> operator+(const Saturate<T>& aRhs) const
{
Saturate<T> lhs(mValue);
--- a/mfbt/ScopeExit.h
+++ b/mfbt/ScopeExit.h
@@ -97,17 +97,17 @@ public:
MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
: mExitFunction(cleanup)
, mExecuteOnDestruction(true)
{
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
}
ScopeExit(ScopeExit&& rhs)
- : mExitFunction(mozilla::Move(rhs.mExitFunction))
+ : mExitFunction(std::move(rhs.mExitFunction))
, mExecuteOnDestruction(rhs.mExecuteOnDestruction)
{
rhs.release();
}
~ScopeExit() {
if (mExecuteOnDestruction) {
mExitFunction();
@@ -123,14 +123,14 @@ private:
ScopeExit& operator=(const ScopeExit&) = delete;
ScopeExit& operator=(ScopeExit&&) = delete;
};
template <typename ExitFunction>
MOZ_MUST_USE ScopeExit<ExitFunction>
MakeScopeExit(ExitFunction&& exitFunction)
{
- return ScopeExit<ExitFunction>(mozilla::Move(exitFunction));
+ return ScopeExit<ExitFunction>(std::move(exitFunction));
}
} /* namespace mozilla */
#endif /* mozilla_ScopeExit_h */
--- a/mfbt/Scoped.h
+++ b/mfbt/Scoped.h
@@ -81,17 +81,17 @@ public:
: mValue(aValue)
{
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
}
/* Move constructor. */
Scoped(Scoped&& aOther
MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
- : mValue(Move(aOther.mValue))
+ : mValue(std::move(aOther.mValue))
{
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
aOther.mValue = Traits::empty();
}
~Scoped() { Traits::release(mValue); }
// Constant getter
@@ -147,17 +147,17 @@ public:
return *this;
}
/* Move assignment operator. */
Scoped& operator=(Scoped&& aRhs)
{
MOZ_ASSERT(&aRhs != this, "self-move-assignment not allowed");
this->~Scoped();
- new(this) Scoped(Move(aRhs));
+ new(this) Scoped(std::move(aRhs));
return *this;
}
private:
explicit Scoped(const Scoped& aValue) = delete;
Scoped& operator=(const Scoped& aValue) = delete;
private:
@@ -181,30 +181,30 @@ struct MOZ_NON_TEMPORARY_CLASS name : pu
typedef typename Super::Resource Resource; \
name& operator=(Resource aRhs) \
{ \
Super::operator=(aRhs); \
return *this; \
} \
name& operator=(name&& aRhs) \
{ \
- Super::operator=(Move(aRhs)); \
+ Super::operator=(std::move(aRhs)); \
return *this; \
} \
explicit name(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM) \
: Super(MOZ_GUARD_OBJECT_NOTIFIER_ONLY_PARAM_TO_PARENT) \
{} \
explicit name(Resource aRhs \
MOZ_GUARD_OBJECT_NOTIFIER_PARAM) \
: Super(aRhs \
MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT) \
{} \
name(name&& aRhs \
MOZ_GUARD_OBJECT_NOTIFIER_PARAM) \
- : Super(Move(aRhs) \
+ : Super(std::move(aRhs) \
MOZ_GUARD_OBJECT_NOTIFIER_PARAM_TO_PARENT) \
{} \
private: \
explicit name(name&) = delete; \
name& operator=(name&) = delete; \
};
/*
--- a/mfbt/SegmentedVector.h
+++ b/mfbt/SegmentedVector.h
@@ -135,17 +135,17 @@ public:
// ideal size was too small, in which case the capacity should be one.
MOZ_ASSERT_IF(
aIdealSegmentSize != 0,
(sizeof(Segment) > aIdealSegmentSize && kSegmentCapacity == 1) ||
aIdealSegmentSize - sizeof(Segment) < sizeof(T));
}
SegmentedVector(SegmentedVector&& aOther)
- : mSegments(mozilla::Move(aOther.mSegments))
+ : mSegments(std::move(aOther.mSegments))
{
}
~SegmentedVector() { Clear(); }
bool IsEmpty() const { return !mSegments.getFirst(); }
// Note that this is O(n) rather than O(1), but the constant factor is very
--- a/mfbt/Tuple.h
+++ b/mfbt/Tuple.h
@@ -143,17 +143,17 @@ struct TupleImpl<Index, HeadT, TailT...>
// Copy and move constructors.
// We'd like to use '= default' to implement these, but MSVC 2013's support
// for '= default' is incomplete and this doesn't work.
TupleImpl(const TupleImpl& aOther)
: Base(Tail(aOther))
, mHead(Head(aOther)) {}
TupleImpl(TupleImpl&& aOther)
- : Base(Move(Tail(aOther)))
+ : Base(std::move(Tail(aOther)))
, mHead(Forward<HeadT>(Head(aOther))) {}
// Assign from a tuple whose elements are convertible to the elements
// of this tuple.
template <typename... OtherElements,
typename = typename EnableIf<
sizeof...(OtherElements) == sizeof...(TailT) + 1>::Type>
TupleImpl& operator=(const TupleImpl<Index, OtherElements...>& aOther)
@@ -164,32 +164,32 @@ struct TupleImpl<Index, HeadT, TailT...>
return *this;
}
template <typename... OtherElements,
typename = typename EnableIf<
sizeof...(OtherElements) == sizeof...(TailT) + 1>::Type>
TupleImpl& operator=(TupleImpl<Index, OtherElements...>&& aOther)
{
typedef TupleImpl<Index, OtherElements...> OtherT;
- Head(*this) = Move(OtherT::Head(aOther));
- Tail(*this) = Move(OtherT::Tail(aOther));
+ Head(*this) = std::move(OtherT::Head(aOther));
+ Tail(*this) = std::move(OtherT::Tail(aOther));
return *this;
}
// Copy and move assignment operators.
TupleImpl& operator=(const TupleImpl& aOther)
{
Head(*this) = Head(aOther);
Tail(*this) = Tail(aOther);
return *this;
}
TupleImpl& operator=(TupleImpl&& aOther)
{
- Head(*this) = Move(Head(aOther));
- Tail(*this) = Move(Tail(aOther));
+ Head(*this) = std::move(Head(aOther));
+ Tail(*this) = std::move(Tail(aOther));
return *this;
}
bool operator==(const TupleImpl& aOther) const
{
return Head(*this) == Head(aOther) && Tail(*this) == Tail(aOther);
}
private:
HeadT mHead; // The element stored at this index in the tuple.
@@ -222,42 +222,42 @@ public:
template <typename OtherHead, typename... OtherTail,
typename = typename EnableIf<
detail::CheckConvertibility<
detail::Group<OtherHead, OtherTail...>,
detail::Group<Elements...>>::value>::Type>
explicit Tuple(OtherHead&& aHead, OtherTail&&... aTail)
: Impl(Forward<OtherHead>(aHead), Forward<OtherTail>(aTail)...) { }
Tuple(const Tuple& aOther) : Impl(aOther) { }
- Tuple(Tuple&& aOther) : Impl(Move(aOther)) { }
+ Tuple(Tuple&& aOther) : Impl(std::move(aOther)) { }
template <typename... OtherElements,
typename = typename EnableIf<
sizeof...(OtherElements) == sizeof...(Elements)>::Type>
Tuple& operator=(const Tuple<OtherElements...>& aOther)
{
static_cast<Impl&>(*this) = aOther;
return *this;
}
template <typename... OtherElements,
typename = typename EnableIf<
sizeof...(OtherElements) == sizeof...(Elements)>::Type>
Tuple& operator=(Tuple<OtherElements...>&& aOther)
{
- static_cast<Impl&>(*this) = Move(aOther);
+ static_cast<Impl&>(*this) = std::move(aOther);
return *this;
}
Tuple& operator=(const Tuple& aOther)
{
static_cast<Impl&>(*this) = aOther;
return *this;
}
Tuple& operator=(Tuple&& aOther)
{
- static_cast<Impl&>(*this) = Move(aOther);
+ static_cast<Impl&>(*this) = std::move(aOther);
return *this;
}
bool operator==(const Tuple& aOther) const
{
return static_cast<const Impl&>(*this) == static_cast<const Impl&>(aOther);
}
};
@@ -279,17 +279,17 @@ public:
template <typename AArg, typename BArg,
typename = typename EnableIf<
detail::CheckConvertibility<
detail::Group<AArg, BArg>,
detail::Group<A, B>>::value>::Type>
explicit Tuple(AArg&& aA, BArg&& aB)
: Impl(Forward<AArg>(aA), Forward<BArg>(aB)) { }
Tuple(const Tuple& aOther) : Impl(aOther) { }
- Tuple(Tuple&& aOther) : Impl(Move(aOther)) { }
+ Tuple(Tuple&& aOther) : Impl(std::move(aOther)) { }
explicit Tuple(const Pair<A, B>& aOther)
: Impl(aOther.first(), aOther.second()) { }
explicit Tuple(Pair<A, B>&& aOther) : Impl(Forward<A>(aOther.first()),
Forward<B>(aOther.second())) { }
explicit Tuple(const std::pair<A, B>& aOther)
: Impl(aOther.first, aOther.second) { }
explicit Tuple(std::pair<A, B>&& aOther) : Impl(Forward<A>(aOther.first),
Forward<B>(aOther.second)) { }
@@ -298,27 +298,27 @@ public:
Tuple& operator=(const Tuple<AArg, BArg>& aOther)
{
static_cast<Impl&>(*this) = aOther;
return *this;
}
template <typename AArg, typename BArg>
Tuple& operator=(Tuple<AArg, BArg>&& aOther)
{
- static_cast<Impl&>(*this) = Move(aOther);
+ static_cast<Impl&>(*this) = std::move(aOther);
return *this;
}
Tuple& operator=(const Tuple& aOther)
{
static_cast<Impl&>(*this) = aOther;
return *this;
}
Tuple& operator=(Tuple&& aOther)
{
- static_cast<Impl&>(*this) = Move(aOther);
+ static_cast<Impl&>(*this) = std::move(aOther);
return *this;
}
template <typename AArg, typename BArg>
Tuple& operator=(const Pair<AArg, BArg>& aOther)
{
Impl::Head(*this) = aOther.first();
Impl::Tail(*this).Head(*this) = aOther.second();
return *this;
@@ -408,21 +408,21 @@ auto Get(const Tuple<Elements...>& aTupl
-> decltype(detail::TupleGetHelper<Index>(aTuple))
{
return detail::TupleGetHelper<Index>(aTuple);
}
// Rvalue reference version.
template<std::size_t Index, typename... Elements>
auto Get(Tuple<Elements...>&& aTuple)
- -> decltype(Move(mozilla::Get<Index>(aTuple)))
+ -> decltype(std::move(mozilla::Get<Index>(aTuple)))
{
// We need a 'mozilla::' qualification here to avoid
// name lookup only finding the current function.
- return Move(mozilla::Get<Index>(aTuple));
+ return std::move(mozilla::Get<Index>(aTuple));
}
/**
* A convenience function for constructing a tuple out of a sequence of
* values without specifying the type of the tuple.
* The type of the tuple is deduced from the types of its elements.
*
* Example:
--- a/mfbt/UniquePtr.h
+++ b/mfbt/UniquePtr.h
@@ -97,23 +97,23 @@ struct PointerType
* g1 = nullptr; // clears g1, deletes the int
*
* UniquePtr<int> g2(new int); // owns that int
* int* p = g2.release(); // g2 leaks its int -- still requires deletion
* delete p; // now freed
*
* struct S { int x; S(int x) : x(x) {} };
* UniquePtr<S> g3, g4(new S(5));
- * g3 = Move(g4); // g3 owns the S, g4 cleared
+ * g3 = std::move(g4); // g3 owns the S, g4 cleared
* S* p = g3.get(); // g3 still owns |p|
* assert(g3->x == 5); // operator-> works (if .get() != nullptr)
* assert((*g3).x == 5); // also operator* (again, if not cleared)
* Swap(g3, g4); // g4 now owns the S, g3 cleared
* g3.swap(g4); // g3 now owns the S, g4 cleared
- * UniquePtr<S> g5(Move(g3)); // g5 owns the S, g3 cleared
+ * UniquePtr<S> g5(std::move(g3)); // g5 owns the S, g3 cleared
* g5.reset(); // deletes the S, g5 cleared
*
* struct FreePolicy { void operator()(void* p) { free(p); } };
* UniquePtr<int, FreePolicy> g6(static_cast<int*>(malloc(sizeof(int))));
* int* ptr = g6.get();
* g6 = nullptr; // calls free(ptr)
*
* Now, carefully note a few things you *can't* do:
@@ -138,20 +138,20 @@ struct PointerType
* instantations, and T pretty much has to have a virtual destructor. In other
* words, this doesn't work:
*
* struct Base { virtual ~Base() {} };
* struct Derived : Base {};
*
* UniquePtr<Base> b1;
* // BAD: DefaultDelete<Base> and DefaultDelete<Derived> don't interconvert
- * UniquePtr<Derived> d1(Move(b));
+ * UniquePtr<Derived> d1(std::move(b));
*
* UniquePtr<Base> b2;
- * UniquePtr<Derived, DefaultDelete<Base>> d2(Move(b2)); // okay
+ * UniquePtr<Derived, DefaultDelete<Base>> d2(std::move(b2)); // okay
*
* UniquePtr is specialized for array types. Specializing with an array type
* creates a smart-pointer version of that array -- not a pointer to such an
* array.
*
* UniquePtr<int[]> arr(new int[5]);
* arr[0] = 4;
*
@@ -248,17 +248,17 @@ public:
// };
//
// If deletion really, truly, must be a variable: you might be able to work
// around this with a deleter class that contains the function reference.
// But this workaround is untried and untested, because variable deletion
// behavior really isn't something you should use.
UniquePtr(Pointer aPtr,
typename RemoveReference<D>::Type&& aD2)
- : mTuple(aPtr, Move(aD2))
+ : mTuple(aPtr, std::move(aD2))
{
static_assert(!IsReference<D>::value,
"rvalue deleter can't be stored by reference");
}
UniquePtr(UniquePtr&& aOther)
: mTuple(aOther.release(), Forward<DeleterType>(aOther.get_deleter()))
{}
@@ -344,18 +344,18 @@ public:
}
}
void swap(UniquePtr& aOther)
{
mTuple.swap(aOther.mTuple);
}
- UniquePtr(const UniquePtr& aOther) = delete; // construct using Move()!
- void operator=(const UniquePtr& aOther) = delete; // assign using Move()!
+ UniquePtr(const UniquePtr& aOther) = delete; // construct using std::move()!
+ void operator=(const UniquePtr& aOther) = delete; // assign using std::move()!
};
// In case you didn't read the comment by the main definition (you should!): the
// UniquePtr<T[]> specialization exists to manage array pointers. It deletes
// such pointers using delete[], it will reject construction and modification
// attempts using U* or U[]. Otherwise it works like the normal UniquePtr.
template<typename T, class D>
class UniquePtr<T[], D>
@@ -409,17 +409,17 @@ public:
{}
// If you encounter an error with MSVC10 about RemoveReference below, along
// the lines that "more than one partial specialization matches the template
// argument list": don't use UniquePtr<T[], reference to function>! See the
// comment by this constructor in the non-T[] specialization above.
UniquePtr(Pointer aPtr,
typename RemoveReference<D>::Type&& aD2)
- : mTuple(aPtr, Move(aD2))
+ : mTuple(aPtr, std::move(aD2))
{
static_assert(!IsReference<D>::value,
"rvalue deleter can't be stored by reference");
}
// Forbidden for the same reasons as stated above.
template<typename U, typename V>
UniquePtr(U&& aU, V&& aV,
@@ -488,18 +488,18 @@ public:
}
}
template<typename U>
void reset(U) = delete;
void swap(UniquePtr& aOther) { mTuple.swap(aOther.mTuple); }
- UniquePtr(const UniquePtr& aOther) = delete; // construct using Move()!
- void operator=(const UniquePtr& aOther) = delete; // assign using Move()!
+ UniquePtr(const UniquePtr& aOther) = delete; // construct using std::move()!
+ void operator=(const UniquePtr& aOther) = delete; // assign using std::move()!
};
/**
* A default deletion policy using plain old operator delete.
*
* Note that this type can be specialized, but authors should beware of the risk
* that the specialization may at some point cease to match (either because it
* gets moved to a different compilation unit or the signature changes). If the
--- a/mfbt/Variant.h
+++ b/mfbt/Variant.h
@@ -213,17 +213,17 @@ struct VariantImplementation<Tag, N, T,
}
}
template<typename Variant>
static void moveConstruct(void* aLhs, Variant&& aRhs) {
if (aRhs.template is<N>()) {
::new (KnownNotNull, aLhs) T(aRhs.template extract<N>());
} else {
- Next::moveConstruct(aLhs, Move(aRhs));
+ Next::moveConstruct(aLhs, std::move(aRhs));
}
}
template<typename Variant>
static void destroy(Variant& aV) {
if (aV.template is<N>()) {
aV.template as<N>().~T();
} else {
@@ -282,17 +282,17 @@ struct AsVariantTemporary
: mValue(Forward<U>(aValue))
{}
AsVariantTemporary(const AsVariantTemporary& aOther)
: mValue(aOther.mValue)
{}
AsVariantTemporary(AsVariantTemporary&& aOther)
- : mValue(Move(aOther.mValue))
+ : mValue(std::move(aOther.mValue))
{}
AsVariantTemporary() = delete;
void operator=(const AsVariantTemporary&) = delete;
void operator=(AsVariantTemporary&&) = delete;
typename RemoveConst<typename RemoveReference<T>::Type>::Type mValue;
};
@@ -566,57 +566,57 @@ public:
*/
template<typename RefT>
MOZ_IMPLICIT Variant(detail::AsVariantTemporary<RefT>&& aValue)
: tag(Impl::template tag<typename detail::SelectVariantType<RefT, Ts...>::Type>())
{
using T = typename detail::SelectVariantType<RefT, Ts...>::Type;
static_assert(detail::SelectVariantType<RefT, Ts...>::count == 1,
"Variant can only be selected by type if that type is unique");
- ::new (KnownNotNull, ptr()) T(Move(aValue.mValue));
+ ::new (KnownNotNull, ptr()) T(std::move(aValue.mValue));
}
/** Copy construction. */
Variant(const Variant& aRhs)
: tag(aRhs.tag)
{
Impl::copyConstruct(ptr(), aRhs);
}
/** Move construction. */
Variant(Variant&& aRhs)
: tag(aRhs.tag)
{
- Impl::moveConstruct(ptr(), Move(aRhs));
+ Impl::moveConstruct(ptr(), std::move(aRhs));
}
/** Copy assignment. */
Variant& operator=(const Variant& aRhs) {
MOZ_ASSERT(&aRhs != this, "self-assign disallowed");
this->~Variant();
::new (KnownNotNull, this) Variant(aRhs);
return *this;
}
/** Move assignment. */
Variant& operator=(Variant&& aRhs) {
MOZ_ASSERT(&aRhs != this, "self-assign disallowed");
this->~Variant();
- ::new (KnownNotNull, this) Variant(Move(aRhs));
+ ::new (KnownNotNull, this) Variant(std::move(aRhs));
return *this;
}
/** Move assignment from AsVariant(). */
template<typename T>
Variant& operator=(detail::AsVariantTemporary<T>&& aValue)
{
static_assert(detail::SelectVariantType<T, Ts...>::count == 1,
"Variant can only be selected by type if that type is unique");
this->~Variant();
- ::new (KnownNotNull, this) Variant(Move(aValue));
+ ::new (KnownNotNull, this) Variant(std::move(aValue));
return *this;
}
~Variant()
{
Impl::destroy(*this);
}
@@ -697,26 +697,26 @@ public:
* safely-destructible state, as determined by the behavior of T's move
* constructor when provided the variant's internal value.
*/
template<typename T>
T extract() {
static_assert(detail::SelectVariantType<T, Ts...>::count == 1,
"provided a type not uniquely found in this Variant's type list");
MOZ_ASSERT(is<T>());
- return T(Move(as<T>()));
+ return T(std::move(as<T>()));
}
template<size_t N>
typename detail::Nth<N, Ts...>::Type extract()
{
static_assert(N < sizeof...(Ts),
"provided an index outside of this Variant's type list");
MOZ_RELEASE_ASSERT(is<N>());
- return typename detail::Nth<N, Ts...>::Type(Move(as<N>()));
+ return typename detail::Nth<N, Ts...>::Type(std::move(as<N>()));
}
// Exhaustive matching of all variant types on the contained value.
/** Match on an immutable const reference. */
template<typename Matcher>
auto
match(Matcher&& aMatcher) const
--- a/mfbt/Vector.h
+++ b/mfbt/Vector.h
@@ -102,17 +102,17 @@ struct VectorImpl
* Move-constructs objects in the uninitialized range
* [aDst, aDst+(aSrcEnd-aSrcStart)) from the range [aSrcStart, aSrcEnd).
*/
template<typename U>
static inline void moveConstruct(T* aDst, U* aSrcStart, U* aSrcEnd)
{
MOZ_ASSERT(aSrcStart <= aSrcEnd);
for (U* p = aSrcStart; p < aSrcEnd; ++p, ++aDst) {
- new_(aDst, Move(*p));
+ new_(aDst, std::move(*p));
}
}
/*
* Copy-constructs objects in the uninitialized range [aDst, aDst+aN) from
* the same object aU.
*/
template<typename U>
@@ -136,17 +136,17 @@ struct VectorImpl
MOZ_ASSERT(!CapacityHasExcessSpace<T>(aNewCap));
T* newbuf = aV.template pod_malloc<T>(aNewCap);
if (MOZ_UNLIKELY(!newbuf)) {
return false;
}
T* dst = newbuf;
T* src = aV.beginNoCheck();
for (; src < aV.endNoCheck(); ++dst, ++src) {
- new_(dst, Move(*src));
+ new_(dst, std::move(*src));
}
VectorImpl::destroy(aV.beginNoCheck(), aV.endNoCheck());
aV.free_(aV.mBegin);
aV.mBegin = newbuf;
/* aV.mLength is unchanged. */
aV.mTail.mCapacity = aNewCap;
return true;
}
@@ -870,17 +870,17 @@ Vector<T, N, AP>::Vector(AP aAP)
{
mBegin = inlineStorage();
}
/* Move constructor. */
template<typename T, size_t N, class AllocPolicy>
MOZ_ALWAYS_INLINE
Vector<T, N, AllocPolicy>::Vector(Vector&& aRhs)
- : AllocPolicy(Move(aRhs))
+ : AllocPolicy(std::move(aRhs))
#ifdef DEBUG
, mEntered(false)
#endif
{
mLength = aRhs.mLength;
mTail.mCapacity = aRhs.mTail.mCapacity;
#ifdef DEBUG
mTail.mReserved = aRhs.mTail.mReserved;
@@ -911,17 +911,17 @@ Vector<T, N, AllocPolicy>::Vector(Vector
/* Move assignment. */
template<typename T, size_t N, class AP>
MOZ_ALWAYS_INLINE Vector<T, N, AP>&
Vector<T, N, AP>::operator=(Vector&& aRhs)
{
MOZ_ASSERT(this != &aRhs, "self-move assignment is prohibited");
this->~Vector();
- new(KnownNotNull, this) Vector(Move(aRhs));
+ new(KnownNotNull, this) Vector(std::move(aRhs));
return *this;
}
template<typename T, size_t N, class AP>
MOZ_ALWAYS_INLINE
Vector<T, N, AP>::~Vector()
{
MOZ_REENTRANCY_GUARD_ET_AL;
@@ -1322,50 +1322,50 @@ Vector<T, N, AP>::insert(T* aP, U&& aVal
size_t pos = aP - begin();
MOZ_ASSERT(pos <= mLength);
size_t oldLength = mLength;
if (pos == oldLength) {
if (!append(Forward<U>(aVal))) {
return nullptr;
}
} else {
- T oldBack = Move(back());
- if (!append(Move(oldBack))) {
+ T oldBack = std::move(back());
+ if (!append(std::move(oldBack))) {
return nullptr;
}
for (size_t i = oldLength - 1; i > pos; --i) {
- (*this)[i] = Move((*this)[i - 1]);
+ (*this)[i] = std::move((*this)[i - 1]);
}
(*this)[pos] = Forward<U>(aVal);
}
return begin() + pos;
}
template<typename T, size_t N, class AP>
inline void
Vector<T, N, AP>::erase(T* aIt)
{
MOZ_ASSERT(begin() <= aIt);
MOZ_ASSERT(aIt < end());
while (aIt + 1 < end()) {
- *aIt = Move(*(aIt + 1));
+ *aIt = std::move(*(aIt + 1));
++aIt;
}
popBack();
}
template<typename T, size_t N, class AP>
inline void
Vector<T, N, AP>::erase(T* aBegin, T* aEnd)
{
MOZ_ASSERT(begin() <= aBegin);
MOZ_ASSERT(aBegin <= aEnd);
MOZ_ASSERT(aEnd <= end());
while (aEnd < end()) {
- *aBegin++ = Move(*aEnd++);
+ *aBegin++ = std::move(*aEnd++);
}
shrinkBy(aEnd - aBegin);
}
template<typename T, size_t N, class AP>
template<typename U>
MOZ_ALWAYS_INLINE bool
Vector<T, N, AP>::append(const U* aInsBegin, const U* aInsEnd)
--- a/mfbt/tests/TestBufferList.cpp
+++ b/mfbt/tests/TestBufferList.cpp
@@ -177,17 +177,17 @@ int main(void)
const size_t kSmallCapacity = 8;
BufferList bl2(0, kSmallCapacity, kSmallCapacity);
bl2.WriteBytes(toWrite, kSmallWrite);
bl2.WriteBytes(toWrite, kSmallWrite);
bl2.WriteBytes(toWrite, kSmallWrite);
- bl = mozilla::Move(bl2);
+ bl = std::move(bl2);
MOZ_RELEASE_ASSERT(bl2.Size() == 0);
MOZ_RELEASE_ASSERT(bl2.Iter().Done());
iter = bl.Iter();
MOZ_RELEASE_ASSERT(iter.AdvanceAcrossSegments(bl, kSmallWrite * 3));
MOZ_RELEASE_ASSERT(iter.Done());
// MoveFallible
--- a/mfbt/tests/TestLinkedList.cpp
+++ b/mfbt/tests/TestLinkedList.cpp
@@ -138,28 +138,28 @@ TestMove()
// list.
SomeClass c2;
c2 = MakeSomeClass(2);
list1.insertBack(&c2);
// Test move assignment of LinkedListElement from an element already in a
// list.
SomeClass c3;
- c3 = Move(c2);
+ c3 = std::move(c2);
MOZ_RELEASE_ASSERT(!c2.isInList());
MOZ_RELEASE_ASSERT(c3.isInList());
// Test move constructor for LinkedList.
- LinkedList<SomeClass> list2(Move(list1));
+ LinkedList<SomeClass> list2(std::move(list1));
{ unsigned int check[] { 1, 2 }; CheckListValues(list2, check); }
MOZ_RELEASE_ASSERT(list1.isEmpty());
// Test move assignment for LinkedList.
LinkedList<SomeClass> list3;
- list3 = Move(list2);
+ list3 = std::move(list2);
{ unsigned int check[] { 1, 2 }; CheckListValues(list3, check); }
MOZ_RELEASE_ASSERT(list2.isEmpty());
list3.clear();
}
static void
TestRemoveAndGet()
@@ -227,17 +227,17 @@ TestRefPtrList()
MOZ_RELEASE_ASSERT(p->mCount == 2);
}
RefPtr<CountedClass> ptr = list.getFirst();
while (ptr) {
MOZ_RELEASE_ASSERT(ptr->mCount == 2);
RefPtr<CountedClass> next = ptr->getNext();
ptr->remove();
- ptr = Move(next);
+ ptr = std::move(next);
}
ptr = nullptr;
MOZ_RELEASE_ASSERT(elt1->mCount == 0);
MOZ_RELEASE_ASSERT(elt2->mCount == 0);
list.insertBack(elt1);
elt1->setNext(elt2);
--- a/mfbt/tests/TestMaybe.cpp
+++ b/mfbt/tests/TestMaybe.cpp
@@ -329,28 +329,28 @@ TestCopyAndMove()
//MOZ_RELEASE_ASSERT(mayBasicValue2->GetStatus() == eWasCopyAssigned);
MOZ_RELEASE_ASSERT(mayBasicValue2->GetTag() == 4);
mayBasicValue->SetTag(5);
mayBasicValue2.reset();
mayBasicValue2.emplace(*mayBasicValue);
MOZ_RELEASE_ASSERT(mayBasicValue2->GetStatus() == eWasCopyConstructed);
MOZ_RELEASE_ASSERT(mayBasicValue2->GetTag() == 5);
- // Check that Move() works. (Another sanity check for move support.)
- Maybe<BasicValue> mayBasicValue3 = Some(Move(*mayBasicValue));
+ // Check that std::move() works. (Another sanity check for move support.)
+ Maybe<BasicValue> mayBasicValue3 = Some(std::move(*mayBasicValue));
MOZ_RELEASE_ASSERT(mayBasicValue3->GetStatus() == eWasMoveConstructed);
MOZ_RELEASE_ASSERT(mayBasicValue3->GetTag() == 5);
MOZ_RELEASE_ASSERT(mayBasicValue->GetStatus() == eWasMovedFrom);
mayBasicValue2->SetTag(6);
- mayBasicValue3 = Some(Move(*mayBasicValue2));
+ mayBasicValue3 = Some(std::move(*mayBasicValue2));
MOZ_RELEASE_ASSERT(mayBasicValue3->GetStatus() == eWasMoveAssigned);
MOZ_RELEASE_ASSERT(mayBasicValue3->GetTag() == 6);
MOZ_RELEASE_ASSERT(mayBasicValue2->GetStatus() == eWasMovedFrom);
Maybe<BasicValue> mayBasicValue4;
- mayBasicValue4.emplace(Move(*mayBasicValue3));
+ mayBasicValue4.emplace(std::move(*mayBasicValue3));
MOZ_RELEASE_ASSERT(mayBasicValue4->GetStatus() == eWasMoveConstructed);
MOZ_RELEASE_ASSERT(mayBasicValue4->GetTag() == 6);
MOZ_RELEASE_ASSERT(mayBasicValue3->GetStatus() == eWasMovedFrom);
// Check that we always get copies for types that don't support moves.
// XXX(seth): These tests fail but probably shouldn't. For now we'll just
// consider using Maybe with types that allow copies but have deleted or
// private move constructors, or which do not support copy assignment, to
@@ -942,23 +942,23 @@ TestTypeConversion()
dest = src;
MOZ_RELEASE_ASSERT(src.isSome() && src->mTag == 2);
MOZ_RELEASE_ASSERT(dest.isSome() && dest->mTag == 2);
MOZ_RELEASE_ASSERT(dest->mStatus == eWasCopyAssigned);
}
{
Maybe<SourceType1> src = Some(SourceType1 {1});
- Maybe<DestType> dest = Move(src);
+ Maybe<DestType> dest = std::move(src);
MOZ_RELEASE_ASSERT(src.isNothing());
MOZ_RELEASE_ASSERT(dest.isSome() && dest->mTag == 1);
MOZ_RELEASE_ASSERT(dest->mStatus == eWasMoveConstructed);
src = Some(SourceType1 {2});
- dest = Move(src);
+ dest = std::move(src);
MOZ_RELEASE_ASSERT(src.isNothing());
MOZ_RELEASE_ASSERT(dest.isSome() && dest->mTag == 2);
MOZ_RELEASE_ASSERT(dest->mStatus == eWasMoveAssigned);
}
{
Maybe<SourceType2> src = Some(SourceType2 {1});
Maybe<DestType> dest = src;
@@ -970,23 +970,23 @@ TestTypeConversion()
dest = src;
MOZ_RELEASE_ASSERT(src.isSome() && src->mTag == 2);
MOZ_RELEASE_ASSERT(dest.isSome() && dest->mTag == 2);
MOZ_RELEASE_ASSERT(dest->mStatus == eWasCopiedFrom);
}
{
Maybe<SourceType2> src = Some(SourceType2 {1});
- Maybe<DestType> dest = Move(src);
+ Maybe<DestType> dest = std::move(src);
MOZ_RELEASE_ASSERT(src.isNothing());
MOZ_RELEASE_ASSERT(dest.isSome() && dest->mTag == 1);
MOZ_RELEASE_ASSERT(dest->mStatus == eWasMovedFrom);
src = Some(SourceType2 {2});
- dest = Move(src);
+ dest = std::move(src);
MOZ_RELEASE_ASSERT(src.isNothing());
MOZ_RELEASE_ASSERT(dest.isSome() && dest->mTag == 2);
MOZ_RELEASE_ASSERT(dest->mStatus == eWasMovedFrom);
}
{
Maybe<int> src = Some(1);
Maybe<DestType> dest = src;
@@ -998,23 +998,23 @@ TestTypeConversion()
dest = src;
MOZ_RELEASE_ASSERT(src.isSome() && *src == 2);
MOZ_RELEASE_ASSERT(dest.isSome() && dest->mTag == 2);
MOZ_RELEASE_ASSERT(dest->mStatus == eWasAssigned);
}
{
Maybe<int> src = Some(1);
- Maybe<DestType> dest = Move(src);
+ Maybe<DestType> dest = std::move(src);
MOZ_RELEASE_ASSERT(src.isNothing());
MOZ_RELEASE_ASSERT(dest.isSome() && dest->mTag == 1);
MOZ_RELEASE_ASSERT(dest->mStatus == eWasConstructed);
src = Some(2);
- dest = Move(src);
+ dest = std::move(src);
MOZ_RELEASE_ASSERT(src.isNothing());
MOZ_RELEASE_ASSERT(dest.isSome() && dest->mTag == 2);
MOZ_RELEASE_ASSERT(dest->mStatus == eWasAssigned);
}
{
Maybe<SourceType1> src = Some(SourceType1 {1});
Maybe<int> dest = src;
@@ -1024,22 +1024,22 @@ TestTypeConversion()
src = Some(SourceType1 {2});
dest = src;
MOZ_RELEASE_ASSERT(src.isSome() && src->mTag == 2);
MOZ_RELEASE_ASSERT(dest.isSome() && *dest == 2);
}
{
Maybe<SourceType1> src = Some(SourceType1 {1});
- Maybe<int> dest = Move(src);
+ Maybe<int> dest = std::move(src);
MOZ_RELEASE_ASSERT(src.isNothing());
MOZ_RELEASE_ASSERT(dest.isSome() && *dest == 1);
src = Some(SourceType1 {2});
- dest = Move(src);
+ dest = std::move(src);
MOZ_RELEASE_ASSERT(src.isNothing());
MOZ_RELEASE_ASSERT(dest.isSome() && *dest == 2);
}
{
Maybe<size_t> src = Some(1);
Maybe<char16_t> dest = src;
MOZ_RELEASE_ASSERT(src.isSome() && *src == 1);
@@ -1048,22 +1048,22 @@ TestTypeConversion()
src = Some(2);
dest = src;
MOZ_RELEASE_ASSERT(src.isSome() && *src == 2);
MOZ_RELEASE_ASSERT(dest.isSome() && *dest == 2);
}
{
Maybe<size_t> src = Some(1);
- Maybe<char16_t> dest = Move(src);
+ Maybe<char16_t> dest = std::move(src);
MOZ_RELEASE_ASSERT(src.isNothing());
MOZ_RELEASE_ASSERT(dest.isSome() && *dest == 1);
src = Some(2);
- dest = Move(src);
+ dest = std::move(src);
MOZ_RELEASE_ASSERT(src.isNothing());
MOZ_RELEASE_ASSERT(dest.isSome() && *dest == 2);
}
return true;
}
// These are quasi-implementation details, but we assert them here to prevent
--- a/mfbt/tests/TestNonDereferenceable.cpp
+++ b/mfbt/tests/TestNonDereferenceable.cpp
@@ -42,17 +42,17 @@ TestNonDereferenceableSimple()
nd2 = nd0;
CHECK(!nd2.value());
// Move-construction.
NonDereferenceable<int> nd3{ NonDereferenceable<int>(&i) };
CHECK(nd3.value() == reinterpret_cast<uintptr_t>(&i));
// Move-assignment.
- nd3 = Move(nd1);
+ nd3 = std::move(nd1);
CHECK(nd3.value() == reinterpret_cast<uintptr_t>(&i2));
// Note: Not testing nd1's value because we don't want to assume what state
// it is left in after move. But at least it should be reusable:
nd1 = &i;
CHECK(nd1.value() == reinterpret_cast<uintptr_t>(&i));
}
void
--- a/mfbt/tests/TestSegmentedVector.cpp
+++ b/mfbt/tests/TestSegmentedVector.cpp
@@ -49,31 +49,31 @@ void TestBasics()
MyVector v;
int i, n;
MOZ_RELEASE_ASSERT(v.IsEmpty());
// Add 100 elements, then check various things.
i = 0;
for ( ; i < 100; i++) {
- gDummy = v.Append(mozilla::Move(i));
+ gDummy = v.Append(std::move(i));
}
MOZ_RELEASE_ASSERT(!v.IsEmpty());
MOZ_RELEASE_ASSERT(v.Length() == 100);
n = 0;
for (auto iter = v.Iter(); !iter.Done(); iter.Next()) {
MOZ_RELEASE_ASSERT(iter.Get() == n);
n++;
}
MOZ_RELEASE_ASSERT(n == 100);
// Add another 900 elements, then re-check.
for ( ; i < 1000; i++) {
- v.InfallibleAppend(mozilla::Move(i));
+ v.InfallibleAppend(std::move(i));
}
MOZ_RELEASE_ASSERT(!v.IsEmpty());
MOZ_RELEASE_ASSERT(v.Length() == 1000);
n = 0;
for (auto iter = v.Iter(); !iter.Done(); iter.Next()) {
MOZ_RELEASE_ASSERT(iter.Get() == n);
n++;
@@ -86,28 +86,28 @@ void TestBasics()
MOZ_RELEASE_ASSERT(v.GetLast() == len - 1);
v.PopLast();
}
MOZ_RELEASE_ASSERT(v.IsEmpty());
MOZ_RELEASE_ASSERT(v.Length() == 0);
// Fill the vector up again to prepare for the clear.
for (i = 0; i < 1000; i++) {
- v.InfallibleAppend(mozilla::Move(i));
+ v.InfallibleAppend(std::move(i));
}
MOZ_RELEASE_ASSERT(!v.IsEmpty());
MOZ_RELEASE_ASSERT(v.Length() == 1000);
v.Clear();
MOZ_RELEASE_ASSERT(v.IsEmpty());
MOZ_RELEASE_ASSERT(v.Length() == 0);
// Fill the vector up to verify PopLastN works.
for (i = 0; i < 1000; ++i) {
- v.InfallibleAppend(mozilla::Move(i));
+ v.InfallibleAppend(std::move(i));
}
MOZ_RELEASE_ASSERT(!v.IsEmpty());
MOZ_RELEASE_ASSERT(v.Length() == 1000);
// Verify we pop the right amount of elements.
v.PopLastN(300);
MOZ_RELEASE_ASSERT(v.Length() == 700);
@@ -153,21 +153,21 @@ void TestConstructorsAndDestructors()
explicitCtorCalls++;
SegmentedVector<NonPOD, segmentSize, InfallibleAllocPolicy> v;
// default constructor called 0 times
MOZ_RELEASE_ASSERT(v.IsEmpty());
gDummy = v.Append(x); // copy constructor called
copyCtorCalls++;
NonPOD y(1); // explicit constructor called
explicitCtorCalls++;
- gDummy = v.Append(mozilla::Move(y)); // move constructor called
+ gDummy = v.Append(std::move(y)); // move constructor called
moveCtorCalls++;
NonPOD z(1); // explicit constructor called
explicitCtorCalls++;
- v.InfallibleAppend(mozilla::Move(z)); // move constructor called
+ v.InfallibleAppend(std::move(z)); // move constructor called
moveCtorCalls++;
v.PopLast(); // destructor called 1 time
dtorCalls++;
MOZ_RELEASE_ASSERT(gNumDtors == dtorCalls);
v.Clear(); // destructor called 2 times
dtorCalls += 2;
// Test that PopLastN() correctly calls the destructors of all the
--- a/mfbt/tests/TestTuple.cpp
+++ b/mfbt/tests/TestTuple.cpp
@@ -131,17 +131,17 @@ TestAssignment()
Tuple<int&> c{i};
Tuple<int&> d{j};
c = d;
CHECK(i == 42);
// Move assignment
Tuple<UniquePtr<int>> e{MakeUnique<int>(0)};
Tuple<UniquePtr<int>> f{MakeUnique<int>(42)};
- e = Move(f);
+ e = std::move(f);
CHECK(*Get<0>(e) == 42);
CHECK(Get<0>(f) == nullptr);
}
static void
TestAssignmentFromMozPair()
{
// Copy assignment
@@ -161,17 +161,17 @@ TestAssignmentFromMozPair()
CHECK(i == 42);
CHECK(j == 42);
// Move assignment
Tuple<UniquePtr<int>, UniquePtr<int>> e{MakeUnique<int>(0),
MakeUnique<int>(0)};
Pair<UniquePtr<int>, UniquePtr<int>> f{MakeUnique<int>(42),
MakeUnique<int>(42)};
- e = Move(f);
+ e = std::move(f);
CHECK(*Get<0>(e) == 42);
CHECK(*Get<1>(e) == 42);
CHECK(f.first() == nullptr);
CHECK(f.second() == nullptr);
}
static void
TestAssignmentFromStdPair()
@@ -195,17 +195,17 @@ TestAssignmentFromStdPair()
// Move assignment.
Tuple<UniquePtr<int>, UniquePtr<int>> e{MakeUnique<int>(0), MakeUnique<int>(0)};
// XXX: On some platforms std::pair doesn't support move constructor.
pair<UniquePtr<int>, UniquePtr<int>> f;
f.first = MakeUnique<int>(42);
f.second = MakeUnique<int>(42);
- e = Move(f);
+ e = std::move(f);
CHECK(*Get<0>(e) == 42);
CHECK(*Get<1>(e) == 42);
CHECK(f.first == nullptr);
CHECK(f.second == nullptr);
}
static void
TestGet()
--- a/mfbt/tests/TestUniquePtr.cpp
+++ b/mfbt/tests/TestUniquePtr.cpp
@@ -70,17 +70,17 @@ ReturnUniqueA()
{
return UniqueA(new B);
}
static UniqueA
ReturnLocalA()
{
UniqueA a(new A);
- return Move(a);
+ return std::move(a);
}
static void
TestDeleterType()
{
// Make sure UniquePtr will use its deleter's pointer type if it defines one.
typedef int* Ptr;
struct Deleter {
@@ -105,17 +105,17 @@ TestDefaultFreeGuts()
n1 = nullptr;
CHECK(!n1);
CHECK(n1.get() == nullptr);
int* p1 = new int;
n1.reset(p1);
CHECK(n1);
- NewInt n2(Move(n1));
+ NewInt n2(std::move(n1));
CHECK(!n1);
CHECK(n1.get() == nullptr);
CHECK(n2.get() == p1);
Swap(n1, n2);
CHECK(n1.get() == p1);
CHECK(n2.get() == nullptr);
@@ -155,37 +155,37 @@ TestDefaultFreeGuts()
CHECK(a1->mX == 5);
a1.reset(nullptr);
CHECK(gADestructorCalls == 2);
CHECK(gBDestructorCalls == 1);
B* bp2 = new B;
UniqueB b1(bp2);
UniqueA a2(nullptr);
- a2 = Move(b1);
+ a2 = std::move(b1);
CHECK(gADestructorCalls == 2);
CHECK(gBDestructorCalls == 1);
- UniqueA a3(Move(a2));
+ UniqueA a3(std::move(a2));
a3 = nullptr;
CHECK(gADestructorCalls == 3);
CHECK(gBDestructorCalls == 2);
B* bp3 = new B;
bp3->mX = 42;
UniqueB b2(bp3);
- UniqueA a4(Move(b2));
+ UniqueA a4(std::move(b2));
CHECK(b2.get() == nullptr);
CHECK((*a4).mX == 42);
CHECK(gADestructorCalls == 3);
CHECK(gBDestructorCalls == 2);
UniqueA a5(new A);
UniqueB b3(new B);
- a5 = Move(b3);
+ a5 = std::move(b3);
CHECK(gADestructorCalls == 4);
CHECK(gBDestructorCalls == 2);
ReturnUniqueA();
CHECK(gADestructorCalls == 5);
CHECK(gBDestructorCalls == 3);
ReturnLocalA();
@@ -194,23 +194,23 @@ TestDefaultFreeGuts()
UniqueA a6(ReturnLocalA());
a6 = nullptr;
CHECK(gADestructorCalls == 7);
CHECK(gBDestructorCalls == 3);
UniqueC c1(new B);
UniqueA a7(new B);
- a7 = Move(c1);
+ a7 = std::move(c1);
CHECK(gADestructorCalls == 8);
CHECK(gBDestructorCalls == 4);
c1.reset(new B);
- UniqueA a8(Move(c1));
+ UniqueA a8(std::move(c1));
CHECK(gADestructorCalls == 8);
CHECK(gBDestructorCalls == 4);
// These smart pointers still own B resources.
CHECK(a4);
CHECK(a5);
CHECK(a7);
CHECK(a8);
@@ -253,17 +253,17 @@ TestFreeClass()
CHECK(FreeClassCounter == 0);
}
CHECK(FreeClassCounter == 1);
NewIntCustom n2;
{
NewIntCustom n3(new int);
CHECK(FreeClassCounter == 1);
- n2 = Move(n3);
+ n2 = std::move(n3);
}
CHECK(FreeClassCounter == 1);
n2 = nullptr;
CHECK(FreeClassCounter == 2);
n2.reset(nullptr);
CHECK(FreeClassCounter == 2);
n2.reset(new int);
@@ -299,35 +299,35 @@ static_assert(sizeof(BDeleterRef) > size
"has to be heavier than a B* to store the reference");
static bool
TestReferenceDeleterGuts()
{
DefaultDelete<int> delInt;
IntDeleterRef id1(new int, delInt);
- IntDeleterRef id2(Move(id1));
+ IntDeleterRef id2(std::move(id1));
CHECK(id1 == nullptr);
CHECK(nullptr != id2);
CHECK(&id1.get_deleter() == &id2.get_deleter());
- IntDeleterRef id3(Move(id2));
+ IntDeleterRef id3(std::move(id2));
DefaultDelete<A> delA;
ADeleterRef a1(new A, delA);
a1.reset(nullptr);
a1.reset(new B);
a1 = nullptr;
BDeleterRef b1(new B, delA);
- a1 = Move(b1);
+ a1 = std::move(b1);
BDeleterRef b2(new B, delA);
- ADeleterRef a2(Move(b2));
+ ADeleterRef a2(std::move(b2));
return true;
}
static bool
TestReferenceDeleter()
{
gADestructorCalls = 0;
@@ -363,17 +363,17 @@ SetMallocedInt(UniquePtr<int, FreeSignat
}
static UniquePtr<int, FreeSignature>
MallocedInt(int aI)
{
UniquePtr<int, FreeSignature>
ptr(static_cast<int*>(malloc(sizeof(int))), free);
*ptr = aI;
- return Move(ptr);
+ return std::move(ptr);
}
static bool
TestFunctionReferenceDeleter()
{
// Look for allocator mismatches and leaks to verify these bits
UniquePtr<int, FreeSignature> i1(MallocedInt(17));
CHECK(*i1 == 17);
@@ -468,17 +468,17 @@ TestArray()
n1 = nullptr;
CHECK(!n1);
CHECK(n1.get() == nullptr);
int* p1 = new int[42];
n1.reset(p1);
CHECK(n1);
- IntArray n2(Move(n1));
+ IntArray n2(std::move(n1));
CHECK(!n1);
CHECK(n1.get() == nullptr);
CHECK(n2.get() == p1);
Swap(n1, n2);
CHECK(n1.get() == p1);
CHECK(n2.get() == nullptr);
@@ -496,19 +496,19 @@ TestArray()
n2.reset(p3);
CHECK(n1.get() == p2);
CHECK(n2.get() == p3);
n1.swap(n2);
CHECK(n2.get() == p2);
CHECK(n1.get() == p3);
- n1 = Move(n2);
+ n1 = std::move(n2);
CHECK(n1.get() == p2);
- n1 = Move(n2);
+ n1 = std::move(n2);
CHECK(n1.get() == nullptr);
UniquePtr<A[]> a1(new A[17]);
static_assert(sizeof(a1) == sizeof(A*),
"stored most efficiently");
UniquePtr<A[]> a2(new A[5], DefaultDelete<A[]>());
a2.reset(nullptr);
--- a/mfbt/tests/TestVariant.cpp
+++ b/mfbt/tests/TestVariant.cpp
@@ -309,31 +309,31 @@ testCopy()
MOZ_RELEASE_ASSERT(v3.as<uint64_t>() == 1);
}
static void
testMove()
{
printf("testMove\n");
Variant<UniquePtr<int>, char> v1(MakeUnique<int>(5));
- Variant<UniquePtr<int>, char> v2(Move(v1));
+ Variant<UniquePtr<int>, char> v2(std::move(v1));
MOZ_RELEASE_ASSERT(v2.is<UniquePtr<int>>());
MOZ_RELEASE_ASSERT(*v2.as<UniquePtr<int>>() == 5);
MOZ_RELEASE_ASSERT(v1.is<UniquePtr<int>>());
MOZ_RELEASE_ASSERT(v1.as<UniquePtr<int>>() == nullptr);
Destroyer::destroyedCount = 0;
{
Variant<char, UniquePtr<Destroyer>> v3(MakeUnique<Destroyer>());
- Variant<char, UniquePtr<Destroyer>> v4(Move(v3));
+ Variant<char, UniquePtr<Destroyer>> v4(std::move(v3));
Variant<char, UniquePtr<Destroyer>> v5('a');
- v5 = Move(v4);
+ v5 = std::move(v4);
auto ptr = v5.extract<UniquePtr<Destroyer>>();
MOZ_RELEASE_ASSERT(Destroyer::destroyedCount == 0);
}
MOZ_RELEASE_ASSERT(Destroyer::destroyedCount == 1);
}
static void
--- a/mfbt/tests/TestVector.cpp
+++ b/mfbt/tests/TestVector.cpp
@@ -44,17 +44,17 @@ mozilla::detail::VectorTesting::testRese
MOZ_RELEASE_ASSERT(bv.reserved() == 3);
MOZ_RELEASE_ASSERT(bv.reserve(5));
MOZ_RELEASE_ASSERT(bv.reserved() == 5);
MOZ_RELEASE_ASSERT(bv.reserve(1));
MOZ_RELEASE_ASSERT(bv.reserved() == 5);
- Vector<bool> bv2(Move(bv));
+ Vector<bool> bv2(std::move(bv));
MOZ_RELEASE_ASSERT(bv.reserved() == 0);
MOZ_RELEASE_ASSERT(bv2.reserved() == 5);
bv2.clearAndFree();
MOZ_RELEASE_ASSERT(bv2.reserved() == 0);
Vector<int, 42> iv;
MOZ_RELEASE_ASSERT(iv.reserved() == 0);
@@ -72,17 +72,17 @@ mozilla::detail::VectorTesting::testRese
MOZ_RELEASE_ASSERT(iv.reserved() == 5);
MOZ_RELEASE_ASSERT(iv.reserve(1));
MOZ_RELEASE_ASSERT(iv.reserved() == 5);
MOZ_RELEASE_ASSERT(iv.reserve(55));
MOZ_RELEASE_ASSERT(iv.reserved() == 55);
- Vector<int, 42> iv2(Move(iv));
+ Vector<int, 42> iv2(std::move(iv));
MOZ_RELEASE_ASSERT(iv.reserved() == 0);
MOZ_RELEASE_ASSERT(iv2.reserved() == 55);
iv2.clearAndFree();
MOZ_RELEASE_ASSERT(iv2.reserved() == 0);
#endif
}
@@ -128,31 +128,31 @@ struct S
: j(j)
, k(MakeUnique<size_t>(k))
{
constructCount++;
}
S(S&& rhs)
: j(rhs.j)
- , k(Move(rhs.k))
+ , k(std::move(rhs.k))
{
rhs.j = 0;
rhs.k.reset(0);
moveCount++;
}
~S() {
destructCount++;
}
S& operator=(S&& rhs) {
j = rhs.j;
rhs.j = 0;
- k = Move(rhs.k);
+ k = std::move(rhs.k);
rhs.k.reset();
moveCount++;
return *this;
}
S(const S&) = delete;
S& operator=(const S&) = delete;
};
@@ -168,17 +168,17 @@ mozilla::detail::VectorTesting::testEmpl
{
S::resetCounts();
Vector<S> vec;
MOZ_RELEASE_ASSERT(vec.reserve(20));
for (size_t i = 0; i < 10; i++) {
S s(i, i * i);
- MOZ_RELEASE_ASSERT(vec.append(Move(s)));
+ MOZ_RELEASE_ASSERT(vec.append(std::move(s)));
}
MOZ_RELEASE_ASSERT(vec.length() == 10);
MOZ_RELEASE_ASSERT(S::constructCount == 10);
MOZ_RELEASE_ASSERT(S::moveCount == 10);
for (size_t i = 10; i < 20; i++) {
MOZ_RELEASE_ASSERT(vec.emplaceBack(i, i * i));
@@ -200,17 +200,17 @@ mozilla::detail::VectorTesting::testReve
// Use UniquePtr to make sure that reverse() can handler move-only types.
Vector<UniquePtr<uint8_t>, 0> vec;
// Reverse an odd number of elements.
for (uint8_t i = 0; i < 5; i++) {
auto p = MakeUnique<uint8_t>(i);
MOZ_RELEASE_ASSERT(p);
- MOZ_RELEASE_ASSERT(vec.append(mozilla::Move(p)));
+ MOZ_RELEASE_ASSERT(vec.append(std::move(p)));
}
vec.reverse();
MOZ_RELEASE_ASSERT(*vec[0] == 4);
MOZ_RELEASE_ASSERT(*vec[1] == 3);
MOZ_RELEASE_ASSERT(*vec[2] == 2);
MOZ_RELEASE_ASSERT(*vec[3] == 1);
@@ -234,17 +234,17 @@ mozilla::detail::VectorTesting::testReve
MOZ_RELEASE_ASSERT(vec.length() == 0);
// Reverse a vector using only inline storage.
Vector<UniquePtr<uint8_t>, 5> vec2;
for (uint8_t i = 0; i < 5; i++) {
auto p = MakeUnique<uint8_t>(i);
MOZ_RELEASE_ASSERT(p);
- MOZ_RELEASE_ASSERT(vec2.append(mozilla::Move(p)));
+ MOZ_RELEASE_ASSERT(vec2.append(std::move(p)));
}
vec2.reverse();
MOZ_RELEASE_ASSERT(*vec2[0] == 4);
MOZ_RELEASE_ASSERT(*vec2[1] == 3);
MOZ_RELEASE_ASSERT(*vec2[2] == 2);
MOZ_RELEASE_ASSERT(*vec2[3] == 1);
@@ -439,17 +439,17 @@ mozilla::detail::VectorTesting::testInse
MOZ_RELEASE_ASSERT(vec.length() == 7);
MOZ_ASSERT(vec.reserved() == 8);
MOZ_RELEASE_ASSERT(S::constructCount == 7);
MOZ_RELEASE_ASSERT(S::moveCount == 0);
MOZ_RELEASE_ASSERT(S::destructCount == 0);
S s(42, 43);
- MOZ_RELEASE_ASSERT(vec.insert(vec.begin() + 4, Move(s)));
+ MOZ_RELEASE_ASSERT(vec.insert(vec.begin() + 4, std::move(s)));
for (size_t i = 0; i < vec.length(); i++) {
const S& s = vec[i];
MOZ_RELEASE_ASSERT(s.k);
if (i < 4) {
MOZ_RELEASE_ASSERT(s.j == i && *s.k == i * i);
} else if (i == 4) {
MOZ_RELEASE_ASSERT(s.j == 42 && *s.k == 43);
--- a/modules/libjar/zipwriter/nsZipHeader.cpp
+++ b/modules/libjar/zipwriter/nsZipHeader.cpp
@@ -367,17 +367,17 @@ nsresult nsZipHeader::PadExtraField(uint
while (pad_size < 4) {
pad_size += aAlignSize;
}
// Extra field length is 2 bytes.
if (mLocalFieldLength + pad_size > 65535) {
return NS_ERROR_FAILURE;
}
- UniquePtr<uint8_t[]> field = Move(mLocalExtraField);
+ UniquePtr<uint8_t[]> field = std::move(mLocalExtraField);
uint32_t pos = mLocalFieldLength;
mLocalExtraField = MakeUnique<uint8_t[]>(mLocalFieldLength + pad_size);
memcpy(mLocalExtraField.get(), field.get(), mLocalFieldLength);
// Use 0xFFFF as tag ID to avoid conflict with other IDs.
// For more information, please read "Extensible data fields" section in:
// http://www.pkware.com/documents/casestudies/APPNOTE.TXT
WRITE16(mLocalExtraField.get(), &pos, 0xFFFF);
--- a/modules/pdfium/pdfium/fpdfsdk/pdfwindow/PWL_Caret.cpp
+++ b/modules/pdfium/pdfium/fpdfsdk/pdfwindow/PWL_Caret.cpp
@@ -108,26 +108,26 @@ void CPWL_Caret::SetCaret(bool bVisible,
const CFX_PointF& ptHead,
const CFX_PointF& ptFoot) {
if (bVisible) {
if (IsVisible()) {
if (m_ptHead != ptHead || m_ptFoot != ptFoot) {
m_ptHead = ptHead;
m_ptFoot = ptFoot;
m_bFlash = true;
- Move(m_rcInvalid, false, true);
+ std::move(m_rcInvalid, false, true);
}
} else {
m_ptHead = ptHead;
m_ptFoot = ptFoot;
EndTimer();
BeginTimer(PWL_CARET_FLASHINTERVAL);
CPWL_Wnd::SetVisible(true);
m_bFlash = true;
- Move(m_rcInvalid, false, true);
+ std::move(m_rcInvalid, false, true);
}
} else {
m_ptHead = CFX_PointF();
m_ptFoot = CFX_PointF();
m_bFlash = false;
if (IsVisible()) {
EndTimer();
CPWL_Wnd::SetVisible(false);
--- a/modules/pdfium/pdfium/fpdfsdk/pdfwindow/PWL_ComboBox.cpp
+++ b/modules/pdfium/pdfium/fpdfsdk/pdfwindow/PWL_ComboBox.cpp
@@ -473,28 +473,28 @@ void CPWL_ComboBox::SetPopup(bool bPopup
rcWindow.bottom -= fPopupRet;
break;
case 1:
rcWindow.top += fPopupRet;
break;
}
m_nPopupWhere = nWhere;
- Move(rcWindow, true, true);
+ std::move(rcWindow, true, true);
#ifdef PDF_ENABLE_XFA
bExit = false;
m_pFillerNotify->OnPopupPostOpen(GetAttachedData(), bExit, 0);
if (bExit)
return;
#endif // PDF_ENABLE_XFA
}
}
} else {
m_bPopup = bPopup;
- Move(m_rcOldWindow, true, true);
+ std::move(m_rcOldWindow, true, true);
}
}
bool CPWL_ComboBox::OnKeyDown(uint16_t nChar, uint32_t nFlag) {
if (!m_pList)
return false;
if (!m_pEdit)
return false;
--- a/modules/pdfium/pdfium/fpdfsdk/pdfwindow/PWL_Edit.cpp
+++ b/modules/pdfium/pdfium/fpdfsdk/pdfwindow/PWL_Edit.cpp
@@ -578,22 +578,22 @@ CFX_FloatRect CPWL_Edit::GetFocusRect()
void CPWL_Edit::ShowVScrollBar(bool bShow) {
if (CPWL_ScrollBar* pScroll = GetVScrollBar()) {
if (bShow) {
if (!pScroll->IsVisible()) {
pScroll->SetVisible(true);
CFX_FloatRect rcWindow = GetWindowRect();
m_rcOldWindow = rcWindow;
rcWindow.right += PWL_SCROLLBAR_WIDTH;
- Move(rcWindow, true, true);
+ std::move(rcWindow, true, true);
}
} else {
if (pScroll->IsVisible()) {
pScroll->SetVisible(false);
- Move(m_rcOldWindow, true, true);
+ std::move(m_rcOldWindow, true, true);
}
}
}
}
bool CPWL_Edit::IsVScrollBarVisible() const {
if (CPWL_ScrollBar* pScroll = GetVScrollBar()) {
return pScroll->IsVisible();
--- a/modules/pdfium/pdfium/fpdfsdk/pdfwindow/PWL_Wnd.h
+++ b/modules/pdfium/pdfium/fpdfsdk/pdfwindow/PWL_Wnd.h
@@ -274,17 +274,17 @@ class CPWL_Wnd : public CPWL_TimerHandle
virtual CFX_FloatRect GetFocusRect() const;
virtual CFX_FloatRect GetClientRect() const;
void InvalidateFocusHandler(IPWL_FocusHandler* handler);
void InvalidateProvider(IPWL_Provider* provider);
void Create(const PWL_CREATEPARAM& cp);
void Destroy();
- void Move(const CFX_FloatRect& rcNew, bool bReset, bool bRefresh);
+ void std::move(const CFX_FloatRect& rcNew, bool bReset, bool bRefresh);
void SetCapture();
void ReleaseCapture();
void DrawAppearance(CFX_RenderDevice* pDevice, CFX_Matrix* pUser2Device);
CPWL_Color GetBackgroundColor() const;
void SetBackgroundColor(const CPWL_Color& color);
--- a/mozglue/misc/interceptor/MMPolicies.h
+++ b/mozglue/misc/interceptor/MMPolicies.h
@@ -72,17 +72,17 @@ public:
MMPolicyInProcess(const MMPolicyInProcess&) = delete;
MMPolicyInProcess& operator=(const MMPolicyInProcess&) = delete;
MMPolicyInProcess(MMPolicyInProcess&& aOther)
: mBase(nullptr)
, mReservationSize(0)
, mCommitOffset(0)
{
- *this = Move(aOther);
+ *this = std::move(aOther);
}
MMPolicyInProcess& operator=(MMPolicyInProcess&& aOther)
{
mBase = aOther.mBase;
aOther.mBase = nullptr;
mCommitOffset = aOther.mCommitOffset;
@@ -266,17 +266,17 @@ public:
MMPolicyOutOfProcess(MMPolicyOutOfProcess&& aOther)
: mProcess(nullptr)
, mMapping(nullptr)
, mLocalView(nullptr)
, mRemoteView(nullptr)
, mReservationSize(0)
, mCommitOffset(0)
{
- *this = Move(aOther);
+ *this = std::move(aOther);
}
MMPolicyOutOfProcess(const MMPolicyOutOfProcess& aOther) = delete;
MMPolicyOutOfProcess& operator=(const MMPolicyOutOfProcess&) = delete;
MMPolicyOutOfProcess& operator=(MMPolicyOutOfProcess&& aOther)
{
Destroy();
--- a/mozglue/misc/interceptor/PatcherBase.h
+++ b/mozglue/misc/interceptor/PatcherBase.h
@@ -30,62 +30,62 @@ protected:
ReadOnlyTargetFunction<MMPolicyT> origFn(mVMPolicy, aOriginalFunction);
// If function entry is jmp rel8 stub to the internal implementation, we
// resolve redirected address from the jump target.
if (origFn[0] == 0xeb) {
int8_t offset = (int8_t)(origFn[1]);
if (offset <= 0) {
// Bail out for negative offset: probably already patched by some
// third-party code.
- return Move(origFn);
+ return std::move(origFn);
}
for (int8_t i = 0; i < offset; i++) {
if (origFn[2 + i] != 0x90) {
// Bail out on insufficient nop space.
- return Move(origFn);
+ return std::move(origFn);
}
}
uintptr_t abstarget = (origFn + 2 + offset).GetAddress();
- return EnsureTargetIsAccessible(Move(origFn), abstarget);
+ return EnsureTargetIsAccessible(std::move(origFn), abstarget);
}
#if defined(_M_IX86)
// If function entry is jmp [disp32] such as used by kernel32,
// we resolve redirected address from import table.
if (origFn[0] == 0xff && origFn[1] == 0x25) {
uintptr_t abstarget = (origFn + 2).template ChasePointer<uintptr_t*>();
- return EnsureTargetIsAccessible(Move(origFn), abstarget);
+ return EnsureTargetIsAccessible(std::move(origFn), abstarget);
}
#elif defined(_M_X64)
// If function entry is jmp [disp32] such as used by kernel32,
// we resolve redirected address from import table.
if (origFn[0] == 0x48 && origFn[1] == 0xff && origFn[2] == 0x25) {
uintptr_t abstarget = (origFn + 3).ChasePointerFromDisp();
- return EnsureTargetIsAccessible(Move(origFn), abstarget);
+ return EnsureTargetIsAccessible(std::move(origFn), abstarget);
}
if (origFn[0] == 0xe9) {
// require for TestDllInterceptor with --disable-optimize
uintptr_t abstarget = (origFn + 1).ReadDisp32AsAbsolute();
- return EnsureTargetIsAccessible(Move(origFn), abstarget);
+ return EnsureTargetIsAccessible(std::move(origFn), abstarget);
}
#endif
- return Move(origFn);
+ return std::move(origFn);
}
private:
ReadOnlyTargetFunction<MMPolicyT>
EnsureTargetIsAccessible(ReadOnlyTargetFunction<MMPolicyT> aOrigFn,
uintptr_t aRedirAddress)
{
if (!mVMPolicy.IsPageAccessible(reinterpret_cast<void*>(aRedirAddress))) {
- return Move(aOrigFn);
+ return std::move(aOrigFn);
}
return ReadOnlyTargetFunction<MMPolicyT>(mVMPolicy, aRedirAddress);
}
protected:
VMPolicy mVMPolicy;
};
--- a/mozglue/misc/interceptor/TargetFunction.h
+++ b/mozglue/misc/interceptor/TargetFunction.h
@@ -51,17 +51,17 @@ public:
WritableTargetFunction(WritableTargetFunction&& aOther)
: mMMPolicy(aOther.mMMPolicy)
, mFunc(aOther.mFunc)
, mNumBytes(aOther.mNumBytes)
, mOffset(aOther.mOffset)
, mStartWriteOffset(aOther.mStartWriteOffset)
, mPrevProt(aOther.mPrevProt)
- , mLocalBytes(Move(aOther.mLocalBytes))
+ , mLocalBytes(std::move(aOther.mLocalBytes))
, mAccumulatedStatus(aOther.mAccumulatedStatus)
{
aOther.mPrevProt = 0;
aOther.mAccumulatedStatus = false;
}
~WritableTargetFunction()
{
@@ -335,17 +335,17 @@ public:
ReadOnlyTargetBytes(const MMPolicyOutOfProcess& aMMPolicy, const void* aBase)
: mMMPolicy(aMMPolicy)
, mBase(reinterpret_cast<const uint8_t*>(aBase))
{
}
ReadOnlyTargetBytes(ReadOnlyTargetBytes&& aOther)
: mMMPolicy(aOther.mMMPolicy)
- , mLocalBytes(Move(aOther.mLocalBytes))
+ , mLocalBytes(std::move(aOther.mLocalBytes))
, mBase(aOther.mBase)
{
}
ReadOnlyTargetBytes(const ReadOnlyTargetBytes& aOther)
: mMMPolicy(aOther.mMMPolicy)
, mBase(aOther.mBase)
{
@@ -477,32 +477,32 @@ class MOZ_STACK_CLASS ReadOnlyTargetFunc
template<>
class TargetBytesPtr<MMPolicyInProcess>
{
public:
typedef TargetBytesPtr<MMPolicyInProcess> Type;
static Type Make(const MMPolicyInProcess& aMMPolicy, const void* aFunc)
{
- return Move(TargetBytesPtr(aMMPolicy, aFunc));
+ return std::move(TargetBytesPtr(aMMPolicy, aFunc));
}
static Type CopyFromOffset(const TargetBytesPtr& aOther,
const uint32_t aOffsetFromOther)
{
- return Move(TargetBytesPtr(aOther, aOffsetFromOther));
+ return std::move(TargetBytesPtr(aOther, aOffsetFromOther));
}
ReadOnlyTargetBytes<MMPolicyInProcess>* operator->()
{
return &mTargetBytes;
}
TargetBytesPtr(TargetBytesPtr&& aOther)
- : mTargetBytes(Move(aOther.mTargetBytes))
+ : mTargetBytes(std::move(aOther.mTargetBytes))
{
}
TargetBytesPtr(const TargetBytesPtr& aOther)
: mTargetBytes(aOther.mTargetBytes)
{
}
@@ -527,24 +527,24 @@ class MOZ_STACK_CLASS ReadOnlyTargetFunc
template <>
class TargetBytesPtr<MMPolicyOutOfProcess>
{
public:
typedef std::shared_ptr<ReadOnlyTargetBytes<MMPolicyOutOfProcess>> Type;
static Type Make(const MMPolicyOutOfProcess& aMMPolicy, const void* aFunc)
{
- return Move(std::make_shared<ReadOnlyTargetBytes<MMPolicyOutOfProcess>>(
+ return std::move(std::make_shared<ReadOnlyTargetBytes<MMPolicyOutOfProcess>>(
aMMPolicy, aFunc));
}
static Type CopyFromOffset(const Type& aOther,
const uint32_t aOffsetFromOther)
{
- return Move(std::make_shared<ReadOnlyTargetBytes<MMPolicyOutOfProcess>>(
+ return std::move(std::make_shared<ReadOnlyTargetBytes<MMPolicyOutOfProcess>>(
*aOther, aOffsetFromOther));
}
};
public:
ReadOnlyTargetFunction(const MMPolicy& aMMPolicy, const void* aFunc)
: mTargetBytes(TargetBytesPtr<MMPolicy>::Make(aMMPolicy, aFunc))
, mOffset(0)
@@ -554,17 +554,17 @@ public:
ReadOnlyTargetFunction(const MMPolicy& aMMPolicy, uintptr_t aFunc)
: mTargetBytes(TargetBytesPtr<MMPolicy>::Make(aMMPolicy,
reinterpret_cast<const void*>(aFunc)))
, mOffset(0)
{
}
ReadOnlyTargetFunction(ReadOnlyTargetFunction&& aOther)
- : mTargetBytes(Move(aOther.mTargetBytes))
+ : mTargetBytes(std::move(aOther.mTargetBytes))
, mOffset(aOther.mOffset)
{
}
ReadOnlyTargetFunction& operator=(const ReadOnlyTargetFunction&) = delete;
ReadOnlyTargetFunction& operator=(ReadOnlyTargetFunction&&) = delete;
~ReadOnlyTargetFunction() = default;
@@ -662,17 +662,17 @@ public:
return WritableTargetFunction<MMPolicy>(mTargetBytes->GetMMPolicy());
}
WritableTargetFunction<MMPolicy> result(
mTargetBytes->GetMMPolicy(),
mTargetBytes->GetBase() + aOffset,
effectiveLength);
- return Move(result);
+ return std::move(result);
}
private:
template <typename T>
struct ChasePointerHelper
{
template <typename MMPolicy>
static T Result(const MMPolicy&, T aValue)
--- a/mozglue/misc/interceptor/Trampoline.h
+++ b/mozglue/misc/interceptor/Trampoline.h
@@ -121,17 +121,17 @@ public:
{
if (mOffset + sizeof(uintptr_t) > mMaxOffset) {
mAccumulatedStatus = false;
return Nothing();
}
auto result = Some(*reinterpret_cast<uintptr_t*>(mLocalBase + mOffset));
mOffset += sizeof(uintptr_t);
- return Move(result);
+ return std::move(result);
}
Maybe<uintptr_t> ReadEncodedPointer()
{
Maybe<uintptr_t> encoded(ReadPointer());
if (!encoded) {
return encoded;
}
--- a/mozglue/misc/interceptor/VMSharingPolicies.h
+++ b/mozglue/misc/interceptor/VMSharingPolicies.h
@@ -40,17 +40,17 @@ public:
Trampoline<MMPolicy> result(this, GetLocalView() + offset,
GetRemoteView() + offset, kChunkSize);
if (!!result) {
++mNextChunkIndex;
}
- return Move(result);
+ return std::move(result);
}
TrampolineCollection<MMPolicy> Items() const
{
return TrampolineCollection<MMPolicy>(*this, GetLocalView(), GetRemoteView(),
kChunkSize, mNextChunkIndex);
}
@@ -60,25 +60,25 @@ public:
}
~VMSharingPolicyUnique() = default;
VMSharingPolicyUnique(const VMSharingPolicyUnique&) = delete;
VMSharingPolicyUnique& operator=(const VMSharingPolicyUnique&) = delete;
VMSharingPolicyUnique(VMSharingPolicyUnique&& aOther)
- : MMPolicy(Move(aOther))
+ : MMPolicy(std::move(aOther))
, mNextChunkIndex(aOther.mNextChunkIndex)
{
aOther.mNextChunkIndex = 0;
}
VMSharingPolicyUnique& operator=(VMSharingPolicyUnique&& aOther)
{
- static_cast<MMPolicy&>(*this) = Move(aOther);
+ static_cast<MMPolicy&>(*this) = std::move(aOther);
mNextChunkIndex = aOther.mNextChunkIndex;
aOther.mNextChunkIndex = 0;
return *this;
}
private:
uint32_t mNextChunkIndex;
};
@@ -102,28 +102,28 @@ class VMSharingPolicyShared : public MMP
explicit ProcMapEntry(HANDLE aProc)
: mPid(::GetProcessId(aProc))
, mVMPolicy(aProc)
{
}
ProcMapEntry(ProcMapEntry&& aOther)
: mPid(aOther.mPid)
- , mVMPolicy(Move(aOther.mVMPolicy))
+ , mVMPolicy(std::move(aOther.mVMPolicy))
{
aOther.mPid = 0;
}
ProcMapEntry(const ProcMapEntry&) = delete;
ProcMapEntry& operator=(const ProcMapEntry&) = delete;
ProcMapEntry& operator=(ProcMapEntry&& aOther)
{
mPid = aOther.mPid;
- mVMPolicy = Move(aOther.mVMPolicy);
+ mVMPolicy = std::move(aOther.mVMPolicy);
aOther.mPid = 0;
return *this;
}
bool operator==(DWORD aPid) const
{
return mPid == aPid;
}
@@ -241,22 +241,22 @@ public:
TrampolineCollection<MMPolicy> Items() const
{
AutoCriticalSection lock(&sCS);
ProcMapEntry* entry;
bool found = find(mPid, &entry);
MOZ_RELEASE_ASSERT(found);
- TrampolineCollection<MMPolicy> items(Move(entry->mVMPolicy.Items()));
+ TrampolineCollection<MMPolicy> items(std::move(entry->mVMPolicy.Items()));
// We need to continue holding the lock until items is destroyed.
items.Lock(sCS);
- return Move(items);
+ return std::move(items);
}
void Clear()
{
// This must be a no-op for shared VM policy; we can't have one interceptor
// wiping out trampolines for all interceptors in the process.
}
--- a/netwerk/base/LoadInfo.cpp
+++ b/netwerk/base/LoadInfo.cpp
@@ -466,17 +466,17 @@ LoadInfo::LoadInfo(nsIPrincipal* aLoadin
, mParentOuterWindowID(aParentOuterWindowID)
, mTopOuterWindowID(aTopOuterWindowID)
, mFrameOuterWindowID(aFrameOuterWindowID)
, mEnforceSecurity(aEnforceSecurity)
, mInitialSecurityCheckDone(aInitialSecurityCheckDone)
, mIsThirdPartyContext(aIsThirdPartyContext)
, mIsDocshellReload(aIsDocshellReload)
, mOriginAttributes(aOriginAttributes)
- , mAncestorPrincipals(Move(aAncestorPrincipals))
+ , mAncestorPrincipals(std::move(aAncestorPrincipals))
, mAncestorOuterWindowIDs(aAncestorOuterWindowIDs)
, mCorsUnsafeHeaders(aCorsUnsafeHeaders)
, mForcePreflight(aForcePreflight)
, mIsPreflight(aIsPreflight)
, mLoadTriggeredFromExternal(aLoadTriggeredFromExternal)
, mServiceWorkerTaintingSynthesized(aServiceWorkerTaintingSynthesized)
{
// Only top level TYPE_DOCUMENT loads can have a null loadingPrincipal
@@ -1293,29 +1293,29 @@ LoadInfo::GetClientInfo()
{
return mClientInfo;
}
void
LoadInfo::GiveReservedClientSource(UniquePtr<ClientSource>&& aClientSource)
{
MOZ_DIAGNOSTIC_ASSERT(aClientSource);
- mReservedClientSource = Move(aClientSource);
+ mReservedClientSource = std::move(aClientSource);
SetReservedClientInfo(mReservedClientSource->Info());
}
UniquePtr<ClientSource>
LoadInfo::TakeReservedClientSource()
{
if (mReservedClientSource) {
// If the reserved ClientInfo was set due to a ClientSource being present,
// then clear that info object when the ClientSource is taken.
mReservedClientInfo.reset();
}
- return Move(mReservedClientSource);
+ return std::move(mReservedClientSource);
}
void
LoadInfo::SetReservedClientInfo(const ClientInfo& aClientInfo)
{
MOZ_DIAGNOSTIC_ASSERT(mInitialClientInfo.isNothing());
mReservedClientInfo.emplace(aClientInfo);
}
--- a/netwerk/base/MemoryDownloader.cpp
+++ b/netwerk/base/MemoryDownloader.cpp
@@ -36,17 +36,17 @@ MemoryDownloader::OnStopRequest(nsIReque
{
MOZ_ASSERT_IF(NS_FAILED(mStatus), NS_FAILED(aStatus));
MOZ_ASSERT(!mData == NS_FAILED(mStatus));
Data data;
data.swap(mData);
RefPtr<IObserver> observer;
observer.swap(mObserver);
observer->OnDownloadComplete(this, aRequest, aCtxt, aStatus,
- mozilla::Move(data));
+ std::move(data));
return NS_OK;
}
nsresult
MemoryDownloader::ConsumeData(nsIInputStream* aIn,
void* aClosure,
const char* aFromRawSegment,
uint32_t aToOffset,
--- a/netwerk/base/PartiallySeekableInputStream.cpp
+++ b/netwerk/base/PartiallySeekableInputStream.cpp
@@ -31,33 +31,33 @@ NS_INTERFACE_MAP_BEGIN(PartiallySeekable
mWeakAsyncInputStreamLength)
NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIInputStreamLengthCallback,
mWeakAsyncInputStreamLength)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStream)
NS_INTERFACE_MAP_END
PartiallySeekableInputStream::PartiallySeekableInputStream(already_AddRefed<nsIInputStream> aInputStream,
uint64_t aBufferSize)
- : mInputStream(Move(aInputStream))
+ : mInputStream(std::move(aInputStream))
, mWeakCloneableInputStream(nullptr)
, mWeakIPCSerializableInputStream(nullptr)
, mWeakAsyncInputStream(nullptr)
, mWeakInputStreamLength(nullptr)
, mWeakAsyncInputStreamLength(nullptr)
, mBufferSize(aBufferSize)
, mPos(0)
, mClosed(false)
, mMutex("PartiallySeekableInputStream::mMutex")
{
Init();
}
PartiallySeekableInputStream::PartiallySeekableInputStream(already_AddRefed<nsIInputStream> aClonedBaseStream,
PartiallySeekableInputStream* aClonedFrom)
- : mInputStream(Move(aClonedBaseStream))
+ : mInputStream(std::move(aClonedBaseStream))
, mWeakCloneableInputStream(nullptr)
, mWeakIPCSerializableInputStream(nullptr)
, mWeakAsyncInputStream(nullptr)
, mCachedBuffer(aClonedFrom->mCachedBuffer)
, mBufferSize(aClonedFrom->mBufferSize)
, mPos(aClonedFrom->mPos)
, mClosed(aClonedFrom->mClosed)
, mMutex("PartiallySeekableInputStream::mMutex")
--- a/netwerk/base/SimpleChannel.cpp
+++ b/netwerk/base/SimpleChannel.cpp
@@ -35,17 +35,17 @@ protected:
virtual nsresult BeginAsyncRead(nsIStreamListener* listener,
nsIRequest** request) override;
private:
UniquePtr<SimpleChannelCallbacks> mCallbacks;
};
SimpleChannel::SimpleChannel(UniquePtr<SimpleChannelCallbacks>&& aCallbacks)
- : mCallbacks(Move(aCallbacks))
+ : mCallbacks(std::move(aCallbacks))
{
EnableSynthesizedProgressEvents(true);
}
nsresult
SimpleChannel::OpenContentStream(bool async, nsIInputStream **streamOut, nsIChannel** channel)
{
NS_ENSURE_TRUE(mCallbacks, NS_ERROR_UNEXPECTED);
@@ -94,17 +94,17 @@ private:
void AddIPDLReference();
RefPtr<SimpleChannelChild> mIPDLRef;
};
NS_IMPL_ISUPPORTS_INHERITED(SimpleChannelChild, SimpleChannel, nsIChildChannel)
SimpleChannelChild::SimpleChannelChild(UniquePtr<SimpleChannelCallbacks>&& aCallbacks)
- : SimpleChannel(Move(aCallbacks))
+ : SimpleChannel(std::move(aCallbacks))
, mIPDLRef(nullptr)
{
}
NS_IMETHODIMP
SimpleChannelChild::ConnectParent(uint32_t aId)
{
MOZ_ASSERT(NS_IsMainThread());
@@ -156,19 +156,19 @@ SimpleChannelChild::ActorDestroy(ActorDe
}
already_AddRefed<nsIChannel>
NS_NewSimpleChannelInternal(nsIURI* aURI, nsILoadInfo* aLoadInfo, UniquePtr<SimpleChannelCallbacks>&& aCallbacks)
{
RefPtr<SimpleChannel> chan;
if (IsNeckoChild()) {
- chan = new SimpleChannelChild(Move(aCallbacks));
+ chan = new SimpleChannelChild(std::move(aCallbacks));
} else {
- chan = new SimpleChannel(Move(aCallbacks));
+ chan = new SimpleChannel(std::move(aCallbacks));
}
chan->SetURI(aURI);
MOZ_ALWAYS_SUCCEEDS(chan->SetLoadInfo(aLoadInfo));
return chan.forget();
}
--- a/netwerk/base/SimpleChannel.h
+++ b/netwerk/base/SimpleChannel.h
@@ -83,28 +83,28 @@ NS_NewSimpleChannelInternal(nsIURI* aURI
*/
template <typename T, typename F1, typename F2>
inline already_AddRefed<nsIChannel>
NS_NewSimpleChannel(nsIURI* aURI, nsILoadInfo* aLoadInfo, T* context, F1&& aStartAsyncRead, F2&& aOpenContentStream)
{
using namespace mozilla;
auto callbacks = MakeUnique<net::SimpleChannelCallbacksImpl<F1, F2, T>>(
- Move(aStartAsyncRead), Move(aOpenContentStream), context);
+ std::move(aStartAsyncRead), std::move(aOpenContentStream), context);
- return net::NS_NewSimpleChannelInternal(aURI, aLoadInfo, Move(callbacks));
+ return net::NS_NewSimpleChannelInternal(aURI, aLoadInfo, std::move(callbacks));
}
template <typename T, typename F1>
inline already_AddRefed<nsIChannel>
NS_NewSimpleChannel(nsIURI* aURI, nsILoadInfo* aLoadInfo, T* context, F1&& aStartAsyncRead)
{
using namespace mozilla;
auto openContentStream = [] (bool async, nsIChannel* channel, T* context) {
return Err(NS_ERROR_NOT_IMPLEMENTED);
};
return NS_NewSimpleChannel(
- aURI, aLoadInfo, context, Move(aStartAsyncRead), Move(openContentStream));
+ aURI, aLoadInfo, context, std::move(aStartAsyncRead), std::move(openContentStream));
}
#endif // SimpleChannel_h
--- a/netwerk/base/nsNetUtil.cpp
+++ b/netwerk/base/nsNetUtil.cpp
@@ -720,17 +720,17 @@ NS_NewInputStreamChannelInternal(nsIChan
{
nsresult rv;
nsCOMPtr<nsIInputStreamChannel> isc =
do_CreateInstance(NS_INPUTSTREAMCHANNEL_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = isc->SetURI(aUri);
NS_ENSURE_SUCCESS(rv, rv);
- nsCOMPtr<nsIInputStream> stream = Move(aStream);
+ nsCOMPtr<nsIInputStream> stream = std::move(aStream);
rv = isc->SetContentStream(stream);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIChannel> channel = do_QueryInterface(isc, &rv);
NS_ENSURE_SUCCESS(rv, rv);
if (!aContentType.IsEmpty()) {
rv = channel->SetContentType(aContentType);
@@ -771,17 +771,17 @@ NS_NewInputStreamChannelInternal(nsIChan
aTriggeringPrincipal,
aLoadingNode,
aSecurityFlags,
aContentPolicyType);
if (!loadInfo) {
return NS_ERROR_UNEXPECTED;
}
- nsCOMPtr<nsIInputStream> stream = Move(aStream);
+ nsCOMPtr<nsIInputStream> stream = std::move(aStream);
return NS_NewInputStreamChannelInternal(outChannel,
aUri,
stream.forget(),
aContentType,
aContentCharset,
loadInfo);
}
@@ -890,17 +890,17 @@ NS_NewInputStreamChannel(nsIChannel
nsresult
NS_NewInputStreamPump(nsIInputStreamPump** aResult,
already_AddRefed<nsIInputStream> aStream,
uint32_t aSegsize /* = 0 */,
uint32_t aSegcount /* = 0 */,
bool aCloseWhenDone /* = false */,
nsIEventTarget* aMainThreadTarget /* = nullptr */)
{
- nsCOMPtr<nsIInputStream> stream = Move(aStream);
+ nsCOMPtr<nsIInputStream> stream = std::move(aStream);
nsresult rv;
nsCOMPtr<nsIInputStreamPump> pump =
do_CreateInstance(NS_INPUTSTREAMPUMP_CONTRACTID, &rv);
if (NS_SUCCEEDED(rv)) {
rv = pump->Init(stream, aSegsize, aSegcount, aCloseWhenDone,
aMainThreadTarget);
if (NS_SUCCEEDED(rv)) {
@@ -1480,17 +1480,17 @@ NS_NewLocalFileStream(nsIFileStream **re
return rv;
}
nsresult
NS_NewBufferedOutputStream(nsIOutputStream** aResult,
already_AddRefed<nsIOutputStream> aOutputStream,
uint32_t aBufferSize)
{
- nsCOMPtr<nsIOutputStream> outputStream = Move(aOutputStream);
+ nsCOMPtr<nsIOutputStream> outputStream = std::move(aOutputStream);
nsresult rv;
nsCOMPtr<nsIBufferedOutputStream> out =
do_CreateInstance(NS_BUFFEREDOUTPUTSTREAM_CONTRACTID, &rv);
if (NS_SUCCEEDED(rv)) {
rv = out->Init(outputStream, aBufferSize);
if (NS_SUCCEEDED(rv)) {
out.forget(aResult);
@@ -1499,17 +1499,17 @@ NS_NewBufferedOutputStream(nsIOutputStre
return rv;
}
MOZ_MUST_USE nsresult
NS_NewBufferedInputStream(nsIInputStream** aResult,
already_AddRefed<nsIInputStream> aInputStream,
uint32_t aBufferSize)
{
- nsCOMPtr<nsIInputStream> inputStream = Move(aInputStream);
+ nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream);
nsresult rv;
nsCOMPtr<nsIBufferedInputStream> in =
do_CreateInstance(NS_BUFFEREDINPUTSTREAM_CONTRACTID, &rv);
if (NS_SUCCEEDED(rv)) {
rv = in->Init(inputStream, aBufferSize);
if (NS_SUCCEEDED(rv)) {
in.forget(aResult);
--- a/netwerk/base/nsProtocolProxyService.cpp
+++ b/netwerk/base/nsProtocolProxyService.cpp
@@ -1873,27 +1873,27 @@ nsProtocolProxyService::InsertFilterLink
NS_IMETHODIMP
nsProtocolProxyService::RegisterFilter(nsIProtocolProxyFilter *filter,
uint32_t position)
{
UnregisterFilter(filter); // remove this filter if we already have it
RefPtr<FilterLink> link = new FilterLink(position, filter);
- return InsertFilterLink(Move(link));
+ return InsertFilterLink(std::move(link));
}
NS_IMETHODIMP
nsProtocolProxyService::RegisterChannelFilter(nsIProtocolProxyChannelFilter *channelFilter,
uint32_t position)
{
UnregisterChannelFilter(channelFilter); // remove this filter if we already have it
RefPtr<FilterLink> link = new FilterLink(position, channelFilter);
- return InsertFilterLink(Move(link));
+ return InsertFilterLink(std::move(link));
}
nsresult
nsProtocolProxyService::RemoveFilterLink(nsISupports* givenObject)
{
LOG(("nsProtocolProxyService::RemoveFilterLink target=%p", givenObject));
return mFilters.RemoveElement(givenObject, ProxyFilterObjectComparator())
--- a/netwerk/base/nsSerializationHelper.cpp
+++ b/netwerk/base/nsSerializationHelper.cpp
@@ -35,17 +35,17 @@ NS_SerializeToString(nsISerializable* ob
nsresult
NS_DeserializeObject(const nsACString& str, nsISupports** obj)
{
nsCString decodedData;
nsresult rv = Base64Decode(str, decodedData);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIInputStream> stream;
- rv = NS_NewCStringInputStream(getter_AddRefs(stream), Move(decodedData));
+ rv = NS_NewCStringInputStream(getter_AddRefs(stream), std::move(decodedData));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIObjectInputStream> objstream =
NS_NewObjectInputStream(stream);
return objstream->ReadObject(true, obj);
}
NS_IMPL_ISUPPORTS(nsSerializationHelper, nsISerializationHelper)
--- a/netwerk/base/nsUDPSocket.cpp
+++ b/netwerk/base/nsUDPSocket.cpp
@@ -1146,17 +1146,17 @@ PendingSendStream::OnLookupComplete(nsIC
class SendRequestRunnable: public Runnable {
public:
SendRequestRunnable(nsUDPSocket* aSocket,
const NetAddr& aAddr,
FallibleTArray<uint8_t>&& aData)
: Runnable("net::SendRequestRunnable")
, mSocket(aSocket)
, mAddr(aAddr)
- , mData(Move(aData))
+ , mData(std::move(aData))
{ }
NS_DECL_NSIRUNNABLE
private:
RefPtr<nsUDPSocket> mSocket;
const NetAddr mAddr;
FallibleTArray<uint8_t> mData;
@@ -1265,17 +1265,17 @@ nsUDPSocket::SendWithAddress(const NetAd
*_retval = count;
} else {
FallibleTArray<uint8_t> fallibleArray;
if (!fallibleArray.InsertElementsAt(0, aData, aDataLength, fallible)) {
return NS_ERROR_OUT_OF_MEMORY;
}
nsresult rv = mSts->Dispatch(
- new SendRequestRunnable(this, *aAddr, Move(fallibleArray)),
+ new SendRequestRunnable(this, *aAddr, std::move(fallibleArray)),
NS_DISPATCH_NORMAL);
NS_ENSURE_SUCCESS(rv, rv);
*_retval = aDataLength;
}
return NS_OK;
}
NS_IMETHODIMP
--- a/netwerk/cache2/CacheFile.cpp
+++ b/netwerk/cache2/CacheFile.cpp
@@ -1417,17 +1417,17 @@ CacheFile::AssertOwnsLock() const
mLock.AssertCurrentThreadOwns();
}
void
CacheFile::ReleaseOutsideLock(RefPtr<nsISupports> aObject)
{
AssertOwnsLock();
- mObjsToRelease.AppendElement(Move(aObject));
+ mObjsToRelease.AppendElement(std::move(aObject));
}
nsresult
CacheFile::GetChunkLocked(uint32_t aIndex, ECallerType aCaller,
CacheFileChunkListener *aCallback,
CacheFileChunk **_retval)
{
AssertOwnsLock();
--- a/netwerk/dns/TRR.cpp
+++ b/netwerk/dns/TRR.cpp
@@ -249,17 +249,17 @@ TRR::SendHTTPRequest()
NS_LITERAL_CSTRING("no-store"), false);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIUploadChannel2> uploadChannel = do_QueryInterface(httpChannel);
if (!uploadChannel) {
return NS_ERROR_UNEXPECTED;
}
uint32_t streamLength = body.Length();
nsCOMPtr<nsIInputStream> uploadStream;
- rv = NS_NewCStringInputStream(getter_AddRefs(uploadStream), Move(body));
+ rv = NS_NewCStringInputStream(getter_AddRefs(uploadStream), std::move(body));
NS_ENSURE_SUCCESS(rv, rv);
rv = uploadChannel->ExplicitSetUploadStream(uploadStream,
NS_LITERAL_CSTRING("application/dns-udpwireformat"),
streamLength,
NS_LITERAL_CSTRING("POST"), false);
NS_ENSURE_SUCCESS(rv, rv);
}
--- a/netwerk/dns/nsHostResolver.cpp
+++ b/netwerk/dns/nsHostResolver.cpp
@@ -646,20 +646,20 @@ nsHostResolver::Shutdown()
LinkedList<RefPtr<nsHostRecord>> pendingQHigh, pendingQMed, pendingQLow, evictionQ;
{
MutexAutoLock lock(mLock);
mShutdown = true;
// Move queues to temporary lists.
- pendingQHigh = mozilla::Move(mHighQ);
- pendingQMed = mozilla::Move(mMediumQ);
- pendingQLow = mozilla::Move(mLowQ);
- evictionQ = mozilla::Move(mEvictionQ);
+ pendingQHigh = std::move(mHighQ);
+ pendingQMed = std::move(mMediumQ);
+ pendingQLow = std::move(mLowQ);
+ evictionQ = std::move(mEvictionQ);
mEvictionQSize = 0;
mPendingCount = 0;
if (mNumIdleThreads)
mIdleThreadCV.NotifyAll();
// empty host database
@@ -1636,17 +1636,17 @@ nsHostResolver::CompleteLookup(nsHostRec
} else {
LOG(("CompleteLookup: %s has NO address\n", rec->host.get()));
}
}
if (doCallbacks) {
// get the list of pending callbacks for this lookup, and notify
// them that the lookup is complete.
- mozilla::LinkedList<RefPtr<nsResolveHostCallback>> cbs = mozilla::Move(rec->mCallbacks);
+ mozilla::LinkedList<RefPtr<nsResolveHostCallback>> cbs = std::move(rec->mCallbacks);
LOG(("nsHostResolver record %p calling back dns users\n", rec));
for (nsResolveHostCallback* c = cbs.getFirst(); c; c = c->removeAndGetNext()) {
c->OnResolveHostComplete(this, rec, status);
}
rec->mDidCallbacks = true;
}
--- a/netwerk/ipc/ChannelEventQueue.cpp
+++ b/netwerk/ipc/ChannelEventQueue.cpp
@@ -20,17 +20,17 @@ ChannelEventQueue::TakeEvent()
{
mMutex.AssertCurrentThreadOwns();
MOZ_ASSERT(mFlushing);
if (mSuspended || mEventQueue.IsEmpty()) {
return nullptr;
}
- UniquePtr<ChannelEvent> event(Move(mEventQueue[0]));
+ UniquePtr<ChannelEvent> event(std::move(mEventQueue[0]));
mEventQueue.RemoveElementAt(0);
return event.release();
}
void
ChannelEventQueue::FlushQueue()
{
--- a/netwerk/ipc/ChannelEventQueue.h
+++ b/netwerk/ipc/ChannelEventQueue.h
@@ -185,32 +185,32 @@ ChannelEventQueue::RunOrEnqueue(ChannelE
RecursiveMutexAutoLock lock(mRunningMutex);
{
MutexAutoLock lock(mMutex);
bool enqueue = !!mForcedCount || mSuspended || mFlushing || !mEventQueue.IsEmpty();
if (enqueue) {
- mEventQueue.AppendElement(Move(event));
+ mEventQueue.AppendElement(std::move(event));
return;
}
nsCOMPtr<nsIEventTarget> target = event->GetEventTarget();
MOZ_ASSERT(target);
bool isCurrentThread = false;
DebugOnly<nsresult> rv = target->IsOnCurrentThread(&isCurrentThread);
MOZ_ASSERT(NS_SUCCEEDED(rv));
if (!isCurrentThread) {
// Leverage Suspend/Resume mechanism to trigger flush procedure without
// creating a new one.
SuspendInternal();
- mEventQueue.AppendElement(Move(event));
+ mEventQueue.AppendElement(std::move(event));
ResumeInternal();
return;
}
}
MOZ_RELEASE_ASSERT(!aAssertionWhenNotQueued);
event->Run();
}
@@ -246,17 +246,17 @@ ChannelEventQueue::PrependEvent(UniquePt
// Prepending event while no queue flush foreseen might cause the following
// channel events not run. This assertion here guarantee there must be a
// queue flush, either triggered by Resume or EndForcedQueueing, to execute
// the added event.
MOZ_ASSERT(mSuspended || !!mForcedCount);
UniquePtr<ChannelEvent>* newEvent =
- mEventQueue.InsertElementAt(0, Move(aEvent));
+ mEventQueue.InsertElementAt(0, std::move(aEvent));
if (!newEvent) {
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
@@ -273,17 +273,17 @@ ChannelEventQueue::PrependEvents(nsTArra
UniquePtr<ChannelEvent>* newEvents =
mEventQueue.InsertElementsAt(0, aEvents.Length());
if (!newEvents) {
return NS_ERROR_OUT_OF_MEMORY;
}
for (uint32_t i = 0; i < aEvents.Length(); i++) {
- newEvents[i] = Move(aEvents[i]);
+ newEvents[i] = std::move(aEvents[i]);
}
return NS_OK;
}
inline void
ChannelEventQueue::CompleteResume()
{
--- a/netwerk/ipc/NeckoTargetHolder.cpp
+++ b/netwerk/ipc/NeckoTargetHolder.cpp
@@ -24,19 +24,19 @@ NeckoTargetHolder::GetNeckoTarget()
return target.forget();
}
nsresult
NeckoTargetHolder::Dispatch(already_AddRefed<nsIRunnable>&& aRunnable,
uint32_t aDispatchFlags)
{
if (mNeckoTarget) {
- return mNeckoTarget->Dispatch(Move(aRunnable), aDispatchFlags);
+ return mNeckoTarget->Dispatch(std::move(aRunnable), aDispatchFlags);
}
nsCOMPtr<nsIEventTarget> mainThreadTarget = GetMainThreadEventTarget();
MOZ_ASSERT(mainThreadTarget);
- return mainThreadTarget->Dispatch(Move(aRunnable), aDispatchFlags);
+ return mainThreadTarget->Dispatch(std::move(aRunnable), aDispatchFlags);
}
} // namespace net
} // namespace mozilla
--- a/netwerk/protocol/http/HttpBaseChannel.cpp
+++ b/netwerk/protocol/http/HttpBaseChannel.cpp
@@ -302,17 +302,17 @@ HttpBaseChannel::ReleaseMainThreadOnlyRe
if (mAddedAsNonTailRequest) {
// RemoveNonTailRequest() on our request context must be called on the main thread
MOZ_RELEASE_ASSERT(mRequestContext, "Someone released rc or set flags w/o having it?");
nsCOMPtr<nsISupports> nonTailRemover(new NonTailRemover(mRequestContext));
arrayToRelease.AppendElement(nonTailRemover.forget());
}
- NS_DispatchToMainThread(new ProxyReleaseRunnable(Move(arrayToRelease)));
+ NS_DispatchToMainThread(new ProxyReleaseRunnable(std::move(arrayToRelease)));
}
void
HttpBaseChannel::SetIsTrackingResource()
{
LOG(("HttpBaseChannel::SetIsTrackingResource %p", this));
mIsTrackingResource = true;
}
@@ -2602,17 +2602,17 @@ HttpBaseChannel::AddSecurityMessage(cons
MOZ_ASSERT(NS_IsMainThread());
nsresult rv;
// nsSecurityConsoleMessage is not thread-safe refcounted.
// Delay the object construction until requested.
// See TakeAllSecurityMessages()
Pair<nsString, nsString> pair(aMessageTag, aMessageCategory);
- mSecurityConsoleMessages.AppendElement(Move(pair));
+ mSecurityConsoleMessages.AppendElement(std::move(pair));
nsCOMPtr<nsIConsoleService> console(do_GetService(NS_CONSOLESERVICE_CONTRACTID));
if (!console) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsILoadInfo> loadInfo;
GetLoadInfo(getter_AddRefs(loadInfo));
--- a/netwerk/protocol/http/HttpBaseChannel.h
+++ b/netwerk/protocol/http/HttpBaseChannel.h
@@ -839,17 +839,17 @@ nsresult HttpAsyncAborter<T>::AsyncCall(
return rv;
}
class ProxyReleaseRunnable final : public mozilla::Runnable
{
public:
explicit ProxyReleaseRunnable(nsTArray<nsCOMPtr<nsISupports>>&& aDoomed)
: Runnable("ProxyReleaseRunnable")
- , mDoomed(Move(aDoomed))
+ , mDoomed(std::move(aDoomed))
{}
NS_IMETHOD
Run() override
{
mDoomed.Clear();
return NS_OK;
}
--- a/netwerk/protocol/http/HttpChannelChild.cpp
+++ b/netwerk/protocol/http/HttpChannelChild.cpp
@@ -235,17 +235,17 @@ HttpChannelChild::ReleaseMainThreadOnlyR
// To solve multiple inheritence of nsISupports in InterceptStreamListener
nsCOMPtr<nsIStreamListener> listener = mInterceptListener.forget();
arrayToRelease.AppendElement(listener.forget());
arrayToRelease.AppendElement(mInterceptedRedirectListener.forget());
arrayToRelease.AppendElement(mInterceptedRedirectContext.forget());
- NS_DispatchToMainThread(new ProxyReleaseRunnable(Move(arrayToRelease)));
+ NS_DispatchToMainThread(new ProxyReleaseRunnable(std::move(arrayToRelease)));
}
//-----------------------------------------------------------------------------
// HttpChannelChild::nsISupports
//-----------------------------------------------------------------------------
NS_IMPL_ADDREF(HttpChannelChild)
NS_IMETHODIMP_(MozExternalRefCountType) HttpChannelChild::Release()
@@ -456,17 +456,17 @@ class StartRequestEvent : public NeckoTa
, mCacheExpirationTime(aCacheExpirationTime)
, mCachedCharset(aCachedCharset)
, mSecurityInfoSerialization(aSecurityInfoSerialization)
, mSelfAddr(aSelfAddr)
, mPeerAddr(aPeerAddr)
, mCacheKey(aCacheKey)
, mAltDataType(altDataType)
, mAltDataLen(altDataLen)
- , mController(Move(aController))
+ , mController(std::move(aController))
, mLoadInfoForwarder(loadInfoForwarder)
{}
void Run() override
{
LOG(("StartRequestEvent [this=%p]\n", mChild));
mChild->OnStartRequest(mChannelStatus, mResponseHead, mUseResponseHead,
mRequestHeaders, mLoadInfoForwarder,
@@ -542,17 +542,17 @@ HttpChannelChild::RecvOnStartRequest(con
useResponseHead, requestHeaders,
loadInfoForwarder,
isFromCache, cacheEntryAvailable,
cacheEntryId, cacheFetchCount,
cacheExpirationTime, cachedCharset,
securityInfoSerialization,
selfAddr, peerAddr, cacheKey,
altDataType, altDataLen,
- Move(controller),
+ std::move(controller),
aApplyConversion));
{
// Child's mEventQ is to control the execution order of the IPC messages
// from both main thread IPDL and PBackground IPDL.
// To guarantee the ordering, PBackground IPC messages that are sent after
// OnStartRequest will be throttled until OnStartRequest hits the Child's
// mEventQ.
@@ -2150,17 +2150,17 @@ HttpChannelChild::ConnectParent(uint32_t
MOZ_RELEASE_ASSERT(gSocketTransportService);
RefPtr<HttpChannelChild> self = this;
nsresult rv =
gSocketTransportService->Dispatch(
NewRunnableMethod<RefPtr<HttpChannelChild>>(
"HttpBackgroundChannelChild::Init",
- bgChild, &HttpBackgroundChannelChild::Init, Move(self)),
+ bgChild, &HttpBackgroundChannelChild::Init, std::move(self)),
NS_DISPATCH_NORMAL);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
mBgChild = bgChild.forget();
}
@@ -3943,17 +3943,17 @@ HttpChannelChild::RecvSetPriority(const
{
mPriority = aPriority;
return IPC_OK();
}
mozilla::ipc::IPCResult
HttpChannelChild::RecvAttachStreamFilter(Endpoint<extensions::PStreamFilterParent>&& aEndpoint)
{
- extensions::StreamFilterParent::Attach(this, Move(aEndpoint));
+ extensions::StreamFilterParent::Attach(this, std::move(aEndpoint));
return IPC_OK();
}
mozilla::ipc::IPCResult
HttpChannelChild::RecvCancelDiversion()
{
MOZ_ASSERT(NS_IsMainThread());
--- a/netwerk/protocol/http/nsHttp.cpp
+++ b/netwerk/protocol/http/nsHttp.cpp
@@ -589,17 +589,17 @@ localEnsureBuffer(UniquePtr<T[]> &buf, u
objSize = (newSize + 2048 + 4095) & ~4095;
static_assert(sizeof(T) == 1, "sizeof(T) must be 1");
auto tmp = MakeUnique<T[]>(objSize);
if (preserve) {
memcpy(tmp.get(), buf.get(), preserve);
}
- buf = Move(tmp);
+ buf = std::move(tmp);
}
void EnsureBuffer(UniquePtr<char[]> &buf, uint32_t newSize,
uint32_t preserve, uint32_t &objSize)
{
localEnsureBuffer<char> (buf, newSize, preserve, objSize);
}
--- a/netwerk/protocol/http/nsHttpChannel.cpp
+++ b/netwerk/protocol/http/nsHttpChannel.cpp
@@ -371,17 +371,17 @@ nsHttpChannel::ReleaseMainThreadOnlyRefe
nsTArray<nsCOMPtr<nsISupports>> arrayToRelease;
arrayToRelease.AppendElement(mApplicationCacheForWrite.forget());
arrayToRelease.AppendElement(mAuthProvider.forget());
arrayToRelease.AppendElement(mRedirectURI.forget());
arrayToRelease.AppendElement(mRedirectChannel.forget());
arrayToRelease.AppendElement(mPreflightChannel.forget());
- NS_DispatchToMainThread(new ProxyReleaseRunnable(Move(arrayToRelease)));
+ NS_DispatchToMainThread(new ProxyReleaseRunnable(std::move(arrayToRelease)));
}
nsresult
nsHttpChannel::Init(nsIURI *uri,
uint32_t caps,
nsProxyInfo *proxyInfo,
uint32_t proxyResolveFlags,
nsIURI *proxyURI,
@@ -3244,17 +3244,17 @@ nsHttpChannel::ProcessPartialContent()
// update the cached response head
nsAutoCString head;
mCachedResponseHead->Flatten(head, true);
rv = mCacheEntry->SetMetaDataElement("response-head", head.get());
if (NS_FAILED(rv)) return rv;
// make the cached response be the current response
- mResponseHead = Move(mCachedResponseHead);
+ mResponseHead = std::move(mCachedResponseHead);
UpdateInhibitPersistentCachingFlag();
rv = UpdateExpirationTime();
if (NS_FAILED(rv)) return rv;
// notify observers interested in looking at a response that has been
// merged with any cached headers (http-on-examine-merged-response).
@@ -3392,17 +3392,17 @@ nsHttpChannel::ProcessNotModified()
// update the cached response head
nsAutoCString head;
mCachedResponseHead->Flatten(head, true);
rv = mCacheEntry->SetMetaDataElement("response-head", head.get());
if (NS_FAILED(rv)) return rv;
// make the cached response be the current response
- mResponseHead = Move(mCachedResponseHead);
+ mResponseHead = std::move(mCachedResponseHead);
UpdateInhibitPersistentCachingFlag();
rv = UpdateExpirationTime();
if (NS_FAILED(rv)) return rv;
rv = AddCacheEntryHeaders(mCacheEntry);
if (NS_FAILED(rv)) return rv;
@@ -4861,17 +4861,17 @@ nsHttpChannel::ReadFromCache(bool alread
int64_t diffTime = (currentTime - mOnCacheEntryCheckTimestamp).ToMilliseconds();
Telemetry::Accumulate(Telemetry::NETWORK_RACE_CACHE_WITH_NETWORK_OCEC_ON_START_DIFF, diffTime);
}
return NS_OK;
}
}
if (mCachedResponseHead)
- mResponseHead = Move(mCachedResponseHead);
+ mResponseHead = std::move(mCachedResponseHead);
UpdateInhibitPersistentCachingFlag();
// if we don't already have security info, try to get it from the cache
// entry. there are two cases to consider here: 1) we are just reading
// from the cache, or 2) this may be due to a 304 not modified response,
// in which case we could have security info from a socket transport.
if (!mSecurityInfo)
@@ -6449,20 +6449,20 @@ nsHttpChannel::ProcessId()
bool
nsHttpChannel::AttachStreamFilter(ipc::Endpoint<extensions::PStreamFilterParent>&& aEndpoint)
{
nsCOMPtr<nsIParentChannel> parentChannel;
NS_QueryNotificationCallbacks(this, parentChannel);
RefPtr<HttpChannelParent> httpParent = do_QueryObject(parentChannel);
if (httpParent) {
- return httpParent->SendAttachStreamFilter(Move(aEndpoint));
+ return httpParent->SendAttachStreamFilter(std::move(aEndpoint));
}
- extensions::StreamFilterParent::Attach(this, Move(aEndpoint));
+ extensions::StreamFilterParent::Attach(this, std::move(aEndpoint));
return true;
}
//-----------------------------------------------------------------------------
// nsHttpChannel::nsISupportsPriority
//-----------------------------------------------------------------------------
NS_IMETHODIMP
@@ -7318,17 +7318,17 @@ nsHttpChannel::OnStopRequest(nsIRequest
if (size == int64_t(-1)) {
// mayhemer TODO - we have to restart read from cache here at the size offset
MOZ_ASSERT(false);
LOG((" cache entry write is still in progress, but we just "
"finished reading the cache entry"));
}
else if (contentLength != int64_t(-1) && contentLength != size) {
LOG((" concurrent cache entry write has been interrupted"));
- mCachedResponseHead = Move(mResponseHead);
+ mCachedResponseHead = std::move(mResponseHead);
// Ignore zero partial length because we also want to resume when
// no data at all has been read from the cache.
rv = MaybeSetupByteRangeRequest(size, contentLength, true);
if (NS_SUCCEEDED(rv) && mIsPartialRequest) {
// Prevent read from cache again
mCachedContentIsValid = 0;
mCachedContentIsPartial = 1;
--- a/netwerk/protocol/http/nsHttpConnection.cpp
+++ b/netwerk/protocol/http/nsHttpConnection.cpp
@@ -2139,17 +2139,17 @@ nsHttpConnection::SetupProxyConnect()
"SPDY NPN Complete while using proxy connect stream");
nsAutoCString buf;
nsHttpRequestHead request;
nsresult rv = MakeConnectString(mTransaction, &request, buf);
if (NS_FAILED(rv)) {
return rv;
}
- return NS_NewCStringInputStream(getter_AddRefs(mProxyConnectStream), Move(buf));
+ return NS_NewCStringInputStream(getter_AddRefs(mProxyConnectStream), std::move(buf));
}
nsresult
nsHttpConnection::StartShortLivedTCPKeepalives()
{
if (mUsingSpdyVersion) {
return NS_OK;
}
--- a/netwerk/protocol/http/nsHttpConnectionMgr.cpp
+++ b/netwerk/protocol/http/nsHttpConnectionMgr.cpp
@@ -1117,17 +1117,17 @@ nsHttpConnectionMgr::PreparePendingQForD
LOG(("nsHttpConnectionMgr::PreparePendingQForDispatching "
"focused window pendingQ.Length()=%zu"
", remainingPendingQ.Length()=%zu\n",
pendingQ.Length(), remainingPendingQ.Length()));
// Append elements in |remainingPendingQ| to |pendingQ|. The order in
// |pendingQ| is like: [focusedWindowTrans...nonFocusedWindowTrans].
- pendingQ.AppendElements(Move(remainingPendingQ));
+ pendingQ.AppendElements(std::move(remainingPendingQ));
}
bool
nsHttpConnectionMgr::ProcessPendingQForEntry(nsConnectionEntry *ent, bool considerAll)
{
MOZ_ASSERT(OnSocketThread(), "not on socket thread");
LOG(("nsHttpConnectionMgr::ProcessPendingQForEntry "
--- a/netwerk/protocol/http/nsServerTiming.cpp
+++ b/netwerk/protocol/http/nsServerTiming.cpp
@@ -96,13 +96,13 @@ ServerTimingParser::Parse()
}
}
}
}
nsTArray<nsCOMPtr<nsIServerTiming>>&&
ServerTimingParser::TakeServerTimingHeaders()
{
- return Move(mServerTimingHeaders);
+ return std::move(mServerTimingHeaders);
}
} // namespace net
} // namespace mozilla
--- a/netwerk/protocol/res/ExtensionProtocolHandler.cpp
+++ b/netwerk/protocol/res/ExtensionProtocolHandler.cpp
@@ -86,17 +86,17 @@ class ExtensionStreamGetter : public Ref
// To use when getting an FD for a packed extension JAR file
// in order to load a resource.
ExtensionStreamGetter(nsIURI* aURI, nsILoadInfo* aLoadInfo,
already_AddRefed<nsIJARChannel>&& aJarChannel,
nsIFile* aJarFile)
: mURI(aURI)
, mLoadInfo(aLoadInfo)
- , mJarChannel(Move(aJarChannel))
+ , mJarChannel(std::move(aJarChannel))
, mJarFile(aJarFile)
, mIsJarChannel(true)
{
MOZ_ASSERT(aURI);
MOZ_ASSERT(aLoadInfo);
MOZ_ASSERT(mJarChannel);
MOZ_ASSERT(aJarFile);
@@ -265,17 +265,17 @@ CancelRequest(nsIStreamListener* aListen
// Handle an input stream sent from the parent.
void
ExtensionStreamGetter::OnStream(already_AddRefed<nsIInputStream> aStream)
{
MOZ_ASSERT(IsNeckoChild());
MOZ_ASSERT(mListener);
MOZ_ASSERT(mMainThreadEventTarget);
- nsCOMPtr<nsIInputStream> stream = Move(aStream);
+ nsCOMPtr<nsIInputStream> stream = std::move(aStream);
// We must keep an owning reference to the listener
// until we pass it on to AsyncRead.
nsCOMPtr<nsIStreamListener> listener = mListener.forget();
MOZ_ASSERT(mChannel);
if (!stream) {
--- a/netwerk/protocol/websocket/WebSocketEventService.cpp
+++ b/netwerk/protocol/websocket/WebSocketEventService.cpp
@@ -70,17 +70,17 @@ protected:
class WebSocketFrameRunnable final : public WebSocketBaseRunnable
{
public:
WebSocketFrameRunnable(uint32_t aWebSocketSerialID,
uint64_t aInnerWindowID,
already_AddRefed<WebSocketFrame> aFrame,
bool aFrameSent)
: WebSocketBaseRunnable(aWebSocketSerialID, aInnerWindowID)
- , mFrame(Move(aFrame))
+ , mFrame(std::move(aFrame))
, mFrameSent(aFrameSent)
{}
private:
virtual void DoWork(nsIWebSocketEventListener* aListener) override
{
DebugOnly<nsresult> rv;
if (mFrameSent) {
@@ -335,17 +335,17 @@ WebSocketEventService::WebSocketClosed(u
}
void
WebSocketEventService::FrameReceived(uint32_t aWebSocketSerialID,
uint64_t aInnerWindowID,
already_AddRefed<WebSocketFrame> aFrame,
nsIEventTarget* aTarget)
{
- RefPtr<WebSocketFrame> frame(Move(aFrame));
+ RefPtr<WebSocketFrame> frame(std::move(aFrame));
MOZ_ASSERT(frame);
// Let's continue only if we have some listeners.
if (!HasListeners()) {
return;
}
RefPtr<WebSocketFrameRunnable> runnable =
@@ -358,17 +358,17 @@ WebSocketEventService::FrameReceived(uin
}
void
WebSocketEventService::FrameSent(uint32_t aWebSocketSerialID,
uint64_t aInnerWindowID,
already_AddRefed<WebSocketFrame> aFrame,
nsIEventTarget* aTarget)
{
- RefPtr<WebSocketFrame> frame(Move(aFrame));
+ RefPtr<WebSocketFrame> frame(std::move(aFrame));
MOZ_ASSERT(frame);
// Let's continue only if we have some listeners.
if (!HasListeners()) {
return;
}
RefPtr<WebSocketFrameRunnable> runnable =
--- a/netwerk/socket/nsNamedPipeService.cpp
+++ b/netwerk/socket/nsNamedPipeService.cpp
@@ -38,17 +38,17 @@ NamedPipeService::Init()
MOZ_ASSERT(!mIsShutdown);
nsresult rv;
// nsIObserverService must be accessed in main thread.
// register shutdown event to stop NamedPipeSrv thread.
nsCOMPtr<nsIObserver> self(this);
nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction("NamedPipeService::Init",
- [self = Move(self)] () -> void {
+ [self = std::move(self)] () -> void {
MOZ_ASSERT(NS_IsMainThread());
nsCOMPtr<nsIObserverService> svc = mozilla::services::GetObserverService();
if (NS_WARN_IF(!svc)) {
return;
}
--- a/netwerk/system/mac/nsNetworkLinkService.mm
+++ b/netwerk/system/mac/nsNetworkLinkService.mm
@@ -181,17 +181,17 @@ static bool scanArp(char *ip, char *mac,
st = sysctl(mib, 6, &buf[0], &needed, nullptr, 0);
if (st == 0 || errno != ENOMEM) {
break;
}
needed += needed / 8;
auto tmp = MakeUnique<char[]>(needed);
memcpy(&tmp[0], &buf[0], needed);
- buf = Move(tmp);
+ buf = std::move(tmp);
}
if (st == -1) {
return false;
}
lim = &buf[needed];
struct rt_msghdr *rtm;
for (next = &buf[0]; next < lim; next += rtm->rtm_msglen) {
--- a/other-licenses/7zstub/src/CPP/Windows/Control/Dialog.cpp
+++ b/other-licenses/7zstub/src/CPP/Windows/Control/Dialog.cpp
@@ -172,27 +172,27 @@ void CDialog::NormalizeSize(bool fullNor
rect.bottom = workRect.bottom;
ySize2 = ySize;
}
if (needMove)
{
if (fullNormalize)
Show(SW_SHOWMAXIMIZED);
else
- Move(rect.left, rect.top, xSize2, ySize2, true);
+ std::move(rect.left, rect.top, xSize2, ySize2, true);
}
}
void CDialog::NormalizePosition()
{
RECT workRect, rect;
GetWorkAreaRect(&workRect);
GetWindowRect(&rect);
if (rect.bottom > workRect.bottom && rect.top > workRect.top)
- Move(rect.left, workRect.top, RECT_SIZE_X(rect), RECT_SIZE_Y(rect), true);
+ std::move(rect.left, workRect.top, RECT_SIZE_X(rect), RECT_SIZE_Y(rect), true);
}
bool CModelessDialog::Create(LPCTSTR templateName, HWND parentWindow)
{
HWND aHWND = CreateDialogParam(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
if (aHWND == 0)
return false;
Attach(aHWND);
--- a/other-licenses/7zstub/src/CPP/Windows/Window.h
+++ b/other-licenses/7zstub/src/CPP/Windows/Window.h
@@ -125,17 +125,17 @@ public:
if (_window == NULL)
return true;
bool result = BOOLToBool(::DestroyWindow(_window));
if (result)
_window = NULL;
return result;
}
bool IsWindow() { return BOOLToBool(::IsWindow(_window)); }
- bool Move(int x, int y, int width, int height, bool repaint = true)
+ bool std::move(int x, int y, int width, int height, bool repaint = true)
{ return BOOLToBool(::MoveWindow(_window, x, y, width, height, BoolToBOOL(repaint))); }
bool ChangeSubWindowSizeX(HWND hwnd, int xSize)
{
RECT rect;
::GetWindowRect(hwnd, &rect);
POINT p1;
p1.x = rect.left;
--- a/parser/html/nsHtml5Highlighter.cpp
+++ b/parser/html/nsHtml5Highlighter.cpp
@@ -652,17 +652,17 @@ nsHtml5Highlighter::CompletedNamedCharac
{
AddClass(sEntity);
}
nsIContent**
nsHtml5Highlighter::AllocateContentHandle()
{
if (mHandlesUsed == NS_HTML5_HIGHLIGHTER_HANDLE_ARRAY_LENGTH) {
- mOldHandles.AppendElement(Move(mHandles));
+ mOldHandles.AppendElement(std::move(mHandles));
mHandles =
MakeUnique<nsIContent* []>(NS_HTML5_HIGHLIGHTER_HANDLE_ARRAY_LENGTH);
mHandlesUsed = 0;
}
#ifdef DEBUG
mHandles[mHandlesUsed] = reinterpret_cast<nsIContent*>(uintptr_t(0xC0DEDBAD));
#endif
return &mHandles[mHandlesUsed++];
--- a/parser/html/nsHtml5Speculation.cpp
+++ b/parser/html/nsHtml5Speculation.cpp
@@ -21,16 +21,16 @@ nsHtml5Speculation::nsHtml5Speculation(n
nsHtml5Speculation::~nsHtml5Speculation()
{
MOZ_COUNT_DTOR(nsHtml5Speculation);
}
void
nsHtml5Speculation::MoveOpsFrom(nsTArray<nsHtml5TreeOperation>& aOpQueue)
{
- mOpQueue.AppendElements(Move(aOpQueue));
+ mOpQueue.AppendElements(std::move(aOpQueue));
}
void
nsHtml5Speculation::FlushToSink(nsAHtml5TreeOpSink* aSink)
{
aSink->MoveOpsFrom(mOpQueue);
}
--- a/parser/html/nsHtml5StreamParser.cpp
+++ b/parser/html/nsHtml5StreamParser.cpp
@@ -1218,17 +1218,17 @@ private:
uint32_t mLength;
public:
nsHtml5DataAvailable(nsHtml5StreamParser* aStreamParser,
UniquePtr<uint8_t[]> aData,
uint32_t aLength)
: Runnable("nsHtml5DataAvailable")
, mStreamParser(aStreamParser)
- , mData(Move(aData))
+ , mData(std::move(aData))
, mLength(aLength)
{
}
NS_IMETHOD Run() override
{
mozilla::MutexAutoLock autoLock(mStreamParser->mTokenizerMutex);
mStreamParser->DoDataAvailable(mData.get(), mLength);
return NS_OK;
@@ -1256,17 +1256,17 @@ nsHtml5StreamParser::OnDataAvailable(nsI
return mExecutor->MarkAsBroken(NS_ERROR_OUT_OF_MEMORY);
}
rv =
aInStream->Read(reinterpret_cast<char*>(data.get()), aLength, &totalRead);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(totalRead <= aLength, "Read more bytes than were available?");
nsCOMPtr<nsIRunnable> dataAvailable =
- new nsHtml5DataAvailable(this, Move(data), totalRead);
+ new nsHtml5DataAvailable(this, std::move(data), totalRead);
if (NS_FAILED(
mEventTarget->Dispatch(dataAvailable, nsIThread::DISPATCH_NORMAL))) {
NS_WARNING("Dispatching DataAvailable event failed.");
}
return rv;
} else {
NS_ASSERTION(IsParserThread(), "Wrong thread!");
mozilla::MutexAutoLock autoLock(mTokenizerMutex);
@@ -1822,13 +1822,13 @@ nsHtml5StreamParser::MarkAsBroken(nsresu
NS_WARNING("failed to dispatch executor flush event");
}
}
nsresult
nsHtml5StreamParser::DispatchToMain(already_AddRefed<nsIRunnable>&& aRunnable)
{
if (mDocGroup) {
- return mDocGroup->Dispatch(TaskCategory::Network, Move(aRunnable));
+ return mDocGroup->Dispatch(TaskCategory::Network, std::move(aRunnable));
}
return SchedulerGroup::UnlabeledDispatch(TaskCategory::Network,
- Move(aRunnable));
+ std::move(aRunnable));
}
--- a/parser/html/nsHtml5TreeBuilderCppSupplement.h
+++ b/parser/html/nsHtml5TreeBuilderCppSupplement.h
@@ -1171,17 +1171,17 @@ nsHtml5TreeBuilder::EnsureBufferSpace(in
nsIContentHandle*
nsHtml5TreeBuilder::AllocateContentHandle()
{
if (MOZ_UNLIKELY(mBuilder)) {
MOZ_ASSERT_UNREACHABLE("Must never allocate a handle with builder.");
return nullptr;
}
if (mHandlesUsed == NS_HTML5_TREE_BUILDER_HANDLE_ARRAY_LENGTH) {
- mOldHandles.AppendElement(Move(mHandles));
+ mOldHandles.AppendElement(std::move(mHandles));
mHandles = mozilla::MakeUnique<nsIContent* []>(
NS_HTML5_TREE_BUILDER_HANDLE_ARRAY_LENGTH);
mHandlesUsed = 0;
}
#ifdef DEBUG
mHandles[mHandlesUsed] = reinterpret_cast<nsIContent*>(uintptr_t(0xC0DEDBAD));
#endif
return &mHandles[mHandlesUsed++];
--- a/parser/html/nsHtml5TreeOpExecutor.cpp
+++ b/parser/html/nsHtml5TreeOpExecutor.cpp
@@ -857,17 +857,17 @@ nsHtml5TreeOpExecutor::GetParser()
return static_cast<nsHtml5Parser*>(mParser.get());
}
void
nsHtml5TreeOpExecutor::MoveOpsFrom(nsTArray<nsHtml5TreeOperation>& aOpQueue)
{
MOZ_RELEASE_ASSERT(mFlushState == eNotFlushing,
"Ops added to mOpQueue during tree op execution.");
- mOpQueue.AppendElements(Move(aOpQueue));
+ mOpQueue.AppendElements(std::move(aOpQueue));
}
void
nsHtml5TreeOpExecutor::ClearOpQueue()
{
MOZ_RELEASE_ASSERT(mFlushState == eNotFlushing,
"mOpQueue cleared during tree op execution.");
mOpQueue.Clear();
--- a/parser/html/nsHtml5TreeOpStage.cpp
+++ b/parser/html/nsHtml5TreeOpStage.cpp
@@ -12,43 +12,43 @@ nsHtml5TreeOpStage::nsHtml5TreeOpStage()
}
nsHtml5TreeOpStage::~nsHtml5TreeOpStage() {}
void
nsHtml5TreeOpStage::MoveOpsFrom(nsTArray<nsHtml5TreeOperation>& aOpQueue)
{
mozilla::MutexAutoLock autoLock(mMutex);
- mOpQueue.AppendElements(Move(aOpQueue));
+ mOpQueue.AppendElements(std::move(aOpQueue));
}
void
nsHtml5TreeOpStage::MoveOpsAndSpeculativeLoadsTo(
nsTArray<nsHtml5TreeOperation>& aOpQueue,
nsTArray<nsHtml5SpeculativeLoad>& aSpeculativeLoadQueue)
{
mozilla::MutexAutoLock autoLock(mMutex);
- aOpQueue.AppendElements(Move(mOpQueue));
- aSpeculativeLoadQueue.AppendElements(Move(mSpeculativeLoadQueue));
+ aOpQueue.AppendElements(std::move(mOpQueue));
+ aSpeculativeLoadQueue.AppendElements(std::move(mSpeculativeLoadQueue));
}
void
nsHtml5TreeOpStage::MoveSpeculativeLoadsFrom(
nsTArray<nsHtml5SpeculativeLoad>& aSpeculativeLoadQueue)
{
mozilla::MutexAutoLock autoLock(mMutex);
- mSpeculativeLoadQueue.AppendElements(Move(aSpeculativeLoadQueue));
+ mSpeculativeLoadQueue.AppendElements(std::move(aSpeculativeLoadQueue));
}
void
nsHtml5TreeOpStage::MoveSpeculativeLoadsTo(
nsTArray<nsHtml5SpeculativeLoad>& aSpeculativeLoadQueue)
{
mozilla::MutexAutoLock autoLock(mMutex);
- aSpeculativeLoadQueue.AppendElements(Move(mSpeculativeLoadQueue));
+ aSpeculativeLoadQueue.AppendElements(std::move(mSpeculativeLoadQueue));
}
#ifdef DEBUG
void
nsHtml5TreeOpStage::AssertEmpty()
{
mozilla::MutexAutoLock autoLock(mMutex);
// This shouldn't really need the mutex
--- a/security/certverifier/BTVerifier.cpp
+++ b/security/certverifier/BTVerifier.cpp
@@ -77,28 +77,28 @@ DecodeInclusionProof(pkix::Reader& reade
}
Buffer hashBuffer;
rv = InputToBuffer(hash, hashBuffer);
if (rv != Success) {
return rv;
}
- if (!inclusionPath.append(Move(hashBuffer))) {
+ if (!inclusionPath.append(std::move(hashBuffer))) {
return pkix::Result::FATAL_ERROR_NO_MEMORY;
}
}
if (!reader.AtEnd()){
return pkix::Result::ERROR_BAD_DER;
}
rv = InputToBuffer(logId, result.logId);
if (rv != Success) {
return rv;
}
- result.inclusionPath = Move(inclusionPath);
+ result.inclusionPath = std::move(inclusionPath);
- output = Move(result);
+ output = std::move(result);
return Success;
}
} } //namespace mozilla::ct
--- a/security/certverifier/CTObjectsExtractor.cpp
+++ b/security/certverifier/CTObjectsExtractor.cpp
@@ -233,17 +233,17 @@ private:
return rv;
}
if (!extensionID.MatchRest(EMBEDDED_SCT_LIST_OID)) {
Input extensionTLV;
rv = extensionsReader.GetInput(extensionTLVBegin, extensionTLV);
if (rv != Success) {
return rv;
}
- if (!mExtensionTLVs.append(Move(extensionTLV))) {
+ if (!mExtensionTLVs.append(std::move(extensionTLV))) {
return Result::FATAL_ERROR_NO_MEMORY;
}
}
}
return Success;
}
Result WriteOutput()
@@ -369,17 +369,17 @@ GetPrecertLogEntry(Input leafCertificate
if (rv != Success) {
return rv;
}
Input precertTBS(extractor.GetPrecertTBS());
MOZ_ASSERT(precertTBS.UnsafeGetData() == precertTBSBuffer.begin());
precertTBSBuffer.shrinkTo(precertTBS.GetLength());
output.type = LogEntry::Type::Precert;
- output.tbsCertificate = Move(precertTBSBuffer);
+ output.tbsCertificate = std::move(precertTBSBuffer);
if (!output.issuerKeyHash.resizeUninitialized(SHA256_LENGTH)) {
return Result::FATAL_ERROR_NO_MEMORY;
}
return DigestBufNSS(issuerSubjectPublicKeyInfo, DigestAlgorithm::sha256,
output.issuerKeyHash.begin(),
output.issuerKeyHash.length());
}
--- a/security/certverifier/CTSerialization.cpp
+++ b/security/certverifier/CTSerialization.cpp
@@ -352,17 +352,17 @@ DecodeDigitallySigned(Reader& reader, Di
if (rv != Success) {
return rv;
}
rv = InputToBuffer(signatureData, result.signatureData);
if (rv != Success) {
return rv;
}
- output = Move(result);
+ output = std::move(result);
return Success;
}
Result
EncodeLogEntry(const LogEntry& entry, Buffer& output)
{
Result rv = WriteUint<kLogEntryTypeLength>(
static_cast<unsigned int>(entry.type), output);
@@ -507,17 +507,17 @@ DecodeSignedCertificateTimestamp(Reader&
return rv;
}
rv = InputToBuffer(extensions, result.extensions);
if (rv != Success) {
return rv;
}
result.timestamp = timestamp;
- output = Move(result);
+ output = std::move(result);
return Success;
}
Result
EncodeSCTList(const Vector<pkix::Input>& scts, Buffer& output)
{
// Find out the total size of the SCT list to be written so we can
// write the prefix for the list before writing its contents.
--- a/security/certverifier/CertVerifier.cpp
+++ b/security/certverifier/CertVerifier.cpp
@@ -240,17 +240,17 @@ CertVerifier::LoadKnownCTLogs()
kCTLogOperatorList[log.operatorIndex];
rv = logVerifier.Init(publicKey, logOperator.id, log.status,
log.disqualificationTime);
if (rv != Success) {
MOZ_ASSERT_UNREACHABLE("Failed initializing a known CT Log");
continue;
}
- rv = mCTVerifier->AddLog(Move(logVerifier));
+ rv = mCTVerifier->AddLog(std::move(logVerifier));
if (rv != Success) {
MOZ_ASSERT_UNREACHABLE("Failed activating a known CT Log");
continue;
}
}
// TBD: Initialize mCTDiversityPolicy with the CA dependency map
// of the known CT logs operators.
mCTDiversityPolicy = MakeUnique<CTDiversityPolicy>();
@@ -411,17 +411,17 @@ CertVerifier::VerifyCertificateTranspare
if (rv != Success) {
MOZ_LOG(gCertVerifierLog, LogLevel::Debug,
("CT policy check failed with fatal error %" PRIu32 "\n",
static_cast<uint32_t>(rv)));
return rv;
}
if (ctInfo) {
- ctInfo->verifyResult = Move(result);
+ ctInfo->verifyResult = std::move(result);
ctInfo->policyCompliance = ctPolicyCompliance;
}
return Success;
}
bool
CertVerifier::SHA1ModeMoreRestrictiveThanGivenMode(SHA1Mode mode)
{
--- a/security/certverifier/MultiLogCTVerifier.cpp
+++ b/security/certverifier/MultiLogCTVerifier.cpp
@@ -17,26 +17,26 @@ using namespace mozilla::pkix;
// Note: this moves |verifiedSct| to the target list in |result|.
static Result
StoreVerifiedSct(CTVerifyResult& result,
VerifiedSCT&& verifiedSct,
VerifiedSCT::Status status)
{
verifiedSct.status = status;
- if (!result.verifiedScts.append(Move(verifiedSct))) {
+ if (!result.verifiedScts.append(std::move(verifiedSct))) {
return Result::FATAL_ERROR_NO_MEMORY;
}
return Success;
}
Result
MultiLogCTVerifier::AddLog(CTLogVerifier&& log)
{
- if (!mLogs.append(Move(log))) {
+ if (!mLogs.append(std::move(log))) {
return Result::FATAL_ERROR_NO_MEMORY;
}
return Success;
}
Result
MultiLogCTVerifier::Verify(Input cert,
Input issuerSubjectPublicKeyInfo,
@@ -117,85 +117,85 @@ MultiLogCTVerifier::VerifySCTs(Input enc
Reader encodedSctReader(encodedSct);
SignedCertificateTimestamp sct;
rv = DecodeSignedCertificateTimestamp(encodedSctReader, sct);
if (rv != Success) {
result.decodingErrors++;
continue;
}
- rv = VerifySingleSCT(Move(sct), expectedEntry, origin, time, result);
+ rv = VerifySingleSCT(std::move(sct), expectedEntry, origin, time, result);
if (rv != Success) {
return rv;
}
}
return Success;
}
Result
MultiLogCTVerifier::VerifySingleSCT(SignedCertificateTimestamp&& sct,
const LogEntry& expectedEntry,
VerifiedSCT::Origin origin,
Time time,
CTVerifyResult& result)
{
VerifiedSCT verifiedSct;
verifiedSct.origin = origin;
- verifiedSct.sct = Move(sct);
+ verifiedSct.sct = std::move(sct);
CTLogVerifier* matchingLog = nullptr;
for (auto& log : mLogs) {
if (log.keyId() == verifiedSct.sct.logId) {
matchingLog = &log;
break;
}
}
if (!matchingLog) {
// SCT does not match any known log.
- return StoreVerifiedSct(result, Move(verifiedSct),
+ return StoreVerifiedSct(result, std::move(verifiedSct),
VerifiedSCT::Status::UnknownLog);
}
verifiedSct.logOperatorId = matchingLog->operatorId();
if (!matchingLog->SignatureParametersMatch(verifiedSct.sct.signature)) {
// SCT signature parameters do not match the log's.
- return StoreVerifiedSct(result, Move(verifiedSct),
+ return StoreVerifiedSct(result, std::move(verifiedSct),
VerifiedSCT::Status::InvalidSignature);
}
Result rv = matchingLog->Verify(expectedEntry, verifiedSct.sct);
if (rv != Success) {
if (rv == Result::ERROR_BAD_SIGNATURE) {
- return StoreVerifiedSct(result, Move(verifiedSct),
+ return StoreVerifiedSct(result, std::move(verifiedSct),
VerifiedSCT::Status::InvalidSignature);
}
return rv;
}
// Make sure the timestamp is legitimate (not in the future).
// SCT's |timestamp| is measured in milliseconds since the epoch,
// ignoring leap seconds. When converting it to a second-level precision
// pkix::Time, we need to round it either up or down. In our case, rounding up
// (towards the future) is more "secure", although practically
// it does not matter.
Time sctTime =
TimeFromEpochInSeconds((verifiedSct.sct.timestamp + 999u) / 1000u);
if (sctTime > time) {
- return StoreVerifiedSct(result, Move(verifiedSct),
+ return StoreVerifiedSct(result, std::move(verifiedSct),
VerifiedSCT::Status::InvalidTimestamp);
}
// SCT verified ok, see if the log is qualified. Since SCTs from
// disqualified logs are treated as valid under certain circumstances (see
// the CT Policy), the log qualification check must be the last one we do.
if (matchingLog->isDisqualified()) {
verifiedSct.logDisqualificationTime = matchingLog->disqualificationTime();
- return StoreVerifiedSct(result, Move(verifiedSct),
+ return StoreVerifiedSct(result, std::move(verifiedSct),
VerifiedSCT::Status::ValidFromDisqualifiedLog);
}
- return StoreVerifiedSct(result, Move(verifiedSct),
+ return StoreVerifiedSct(result, std::move(verifiedSct),
VerifiedSCT::Status::Valid);
}
} } // namespace mozilla::ct
--- a/security/certverifier/NSSCertDBTrustDomain.cpp
+++ b/security/certverifier/NSSCertDBTrustDomain.cpp
@@ -571,17 +571,17 @@ NSSCertDBTrustDomain::CheckRevocation(En
if (rv != Success) {
return rv;
}
Vector<uint8_t> ocspRequest;
if (!ocspRequest.append(ocspRequestBytes, ocspRequestLength)) {
return Result::FATAL_ERROR_NO_MEMORY;
}
Result tempRV = DoOCSPRequest(aiaLocation, mOriginAttributes,
- Move(ocspRequest), GetOCSPTimeout(),
+ std::move(ocspRequest), GetOCSPTimeout(),
ocspResponse);
MOZ_ASSERT((tempRV != Success) || ocspResponse.length() > 0);
if (tempRV != Success) {
rv = tempRV;
} else if (response.Init(ocspResponse.begin(), ocspResponse.length())
!= Success) {
rv = Result::ERROR_OCSP_MALFORMED_RESPONSE; // too big
}
@@ -779,17 +779,17 @@ NSSCertDBTrustDomain::IsChainValid(const
}
// Modernization in-progress: Keep certList as a CERTCertList for storage into
// the mBuiltChain variable at the end, but let's use nsNSSCertList for the
// validity calculations.
UniqueCERTCertList certListCopy = nsNSSCertList::DupCertList(certList);
// This adopts the list
- RefPtr<nsNSSCertList> nssCertList = new nsNSSCertList(Move(certListCopy));
+ RefPtr<nsNSSCertList> nssCertList = new nsNSSCertList(std::move(certListCopy));
if (!nssCertList) {
return Result::FATAL_ERROR_LIBRARY_FAILURE;
}
nsCOMPtr<nsIX509Cert> rootCert;
nsresult nsrv = nssCertList->GetRootCertificate(rootCert);
if (NS_FAILED(nsrv)) {
return Result::FATAL_ERROR_LIBRARY_FAILURE;
@@ -907,17 +907,17 @@ NSSCertDBTrustDomain::IsChainValid(const
return Result::FATAL_ERROR_LIBRARY_FAILURE;
}
if (isDistrusted) {
mSawDistrustedCAByPolicyError = true;
return Result::ERROR_ADDITIONAL_POLICY_CONSTRAINT_FAILED;
}
}
- mBuiltChain = Move(certList);
+ mBuiltChain = std::move(certList);
return Success;
}
Result
NSSCertDBTrustDomain::CheckSignatureDigestAlgorithm(DigestAlgorithm aAlg,
EndEntityOrCA endEntityOrCA,
Time notBefore)
--- a/security/certverifier/tests/gtest/CTPolicyEnforcerTest.cpp
+++ b/security/certverifier/tests/gtest/CTPolicyEnforcerTest.cpp
@@ -59,18 +59,18 @@ public:
verifiedSct.logOperatorId = operatorId;
verifiedSct.logDisqualificationTime =
status == VerifiedSCT::Status::ValidFromDisqualifiedLog ?
DISQUALIFIED_AT : UINT64_MAX;
verifiedSct.sct.version = SignedCertificateTimestamp::Version::V1;
verifiedSct.sct.timestamp = timestamp;
Buffer logId;
GetLogId(logId, logNo);
- verifiedSct.sct.logId = Move(logId);
- ASSERT_TRUE(verifiedScts.append(Move(verifiedSct)));
+ verifiedSct.sct.logId = std::move(logId);
+ ASSERT_TRUE(verifiedScts.append(std::move(verifiedSct)));
}
void AddMultipleScts(VerifiedSCTList& verifiedScts,
size_t logsCount,
uint8_t operatorsCount,
VerifiedSCT::Origin origin,
uint64_t timestamp,
VerifiedSCT::Status status = VerifiedSCT::Status::Valid)
--- a/security/certverifier/tests/gtest/CTSerializationTest.cpp
+++ b/security/certverifier/tests/gtest/CTSerializationTest.cpp
@@ -178,18 +178,18 @@ TEST_F(CTSerializationTest, FailsDecodin
}
TEST_F(CTSerializationTest, EncodesSCTList)
{
const uint8_t SCT_1[] = { 0x61, 0x62, 0x63 };
const uint8_t SCT_2[] = { 0x64, 0x65, 0x66 };
Vector<Input> list;
- ASSERT_TRUE(list.append(Move(Input(SCT_1))));
- ASSERT_TRUE(list.append(Move(Input(SCT_2))));
+ ASSERT_TRUE(list.append(std::move(Input(SCT_1))));
+ ASSERT_TRUE(list.append(std::move(Input(SCT_2))));
Buffer encodedList;
ASSERT_EQ(Success, EncodeSCTList(list, encodedList));
Reader listReader;
ASSERT_EQ(Success, DecodeSCTList(InputForBuffer(encodedList), listReader));
Input decoded1;
--- a/security/certverifier/tests/gtest/CTTestUtils.cpp
+++ b/security/certverifier/tests/gtest/CTTestUtils.cpp
@@ -865,17 +865,17 @@ ExtractSCTListFromOCSPResponse(Input cer
bool expired;
OCSPExtensionTrustDomain trustDomain;
pkix::Result rv = VerifyEncodedOCSPResponse(trustDomain, certID,
time, /*time*/
1000, /*maxLifetimeInDays*/
encodedResponse, expired);
ASSERT_EQ(Success, rv);
- result = Move(trustDomain.signedCertificateTimestamps);
+ result = std::move(trustDomain.signedCertificateTimestamps);
}
Buffer
cloneBuffer(const Buffer& buffer)
{
Buffer cloned;
MOZ_RELEASE_ASSERT(cloned.appendAll(buffer));
return cloned;
--- a/security/certverifier/tests/gtest/MultiLogCTVerifierTest.cpp
+++ b/security/certverifier/tests/gtest/MultiLogCTVerifierTest.cpp
@@ -34,17 +34,17 @@ public:
// Does nothing if NSS is already initialized.
MOZ_RELEASE_ASSERT(NSS_NoDB_Init(nullptr) == SECSuccess);
CTLogVerifier log;
ASSERT_EQ(Success, log.Init(InputForBuffer(GetTestPublicKey()),
mLogOperatorID,
CTLogStatus::Included,
0 /*disqualification time*/));
- ASSERT_EQ(Success, mVerifier.AddLog(Move(log)));
+ ASSERT_EQ(Success, mVerifier.AddLog(std::move(log)));
mTestCert = GetDEREncodedX509Cert();
mEmbeddedCert = GetDEREncodedTestEmbeddedCert();
mCaCert = GetDEREncodedCACert();
mCaCertSPKI = ExtractCertSPKI(mCaCert);
mIntermediateCert = GetDEREncodedIntermediateCert();
mIntermediateCertSPKI = ExtractCertSPKI(mIntermediateCert);
@@ -61,17 +61,17 @@ public:
EXPECT_EQ(origin, result.verifiedScts[0].origin);
EXPECT_EQ(mLogOperatorID, result.verifiedScts[0].logOperatorId);
}
// Writes an SCTList containing a single |sct| into |output|.
void EncodeSCTListForTesting(Input sct, Buffer& output)
{
Vector<Input> list;
- ASSERT_TRUE(list.append(Move(sct)));
+ ASSERT_TRUE(list.append(std::move(sct)));
ASSERT_EQ(Success, EncodeSCTList(list, output));
}
void GetSCTListWithInvalidLogID(Buffer& result)
{
result.clear();
Buffer sct(GetTestSignedCertificateTimestamp());
// Change a byte inside the Log ID part of the SCT so it does
@@ -231,17 +231,17 @@ TEST_F(MultiLogCTVerifierTest, Identifie
TEST_F(MultiLogCTVerifierTest, IdentifiesSCTFromDisqualifiedLog)
{
MultiLogCTVerifier verifier;
CTLogVerifier log;
const uint64_t disqualificationTime = 12345u;
ASSERT_EQ(Success, log.Init(InputForBuffer(GetTestPublicKey()),
mLogOperatorID, CTLogStatus::Disqualified, disqualificationTime));
- ASSERT_EQ(Success, verifier.AddLog(Move(log)));
+ ASSERT_EQ(Success, verifier.AddLog(std::move(log)));
Buffer sct(GetTestSignedCertificateTimestamp());
Buffer sctList;
EncodeSCTListForTesting(InputForBuffer(sct), sctList);
CTVerifyResult result;
ASSERT_EQ(Success,
verifier.Verify(InputForBuffer(mTestCert), Input(),
--- a/security/manager/ssl/DataStorage.cpp
+++ b/security/manager/ssl/DataStorage.cpp
@@ -176,17 +176,17 @@ DataStorage::GetAllChildProcessData(
// so do that now!
bool dataWillPersist = false;
nsresult rv = storage->Init(dataWillPersist);
if (NS_WARN_IF(NS_FAILED(rv))) {
return;
}
}
storage->GetAll(&entry.items());
- aEntries.AppendElement(Move(entry));
+ aEntries.AppendElement(std::move(entry));
}
}
// static
void
DataStorage::SetCachedStorageEntries(
const InfallibleTArray<mozilla::dom::DataStorageEntry>& aEntries)
{
@@ -202,21 +202,21 @@ DataStorage::SetCachedStorageEntries(
// of DataStorage items grows some day.
nsTArray<dom::DataStorageEntry> entries;
#define DATA_STORAGE(_) \
{ \
dom::DataStorageEntry entry; \
entry.filename() = NS_LITERAL_STRING(#_ ".txt"); \
for (auto& e : aEntries) { \
if (entry.filename().Equals(e.filename())) { \
- entry.items() = Move(e.items()); \
+ entry.items() = std::move(e.items()); \
break; \
} \
} \
- entries.AppendElement(Move(entry)); \
+ entries.AppendElement(std::move(entry)); \
}
#include "mozilla/DataStorageList.h"
#undef DATA_STORAGE
for (auto& entry : entries) {
RefPtr<DataStorage> storage =
DataStorage::GetFromRawFileName(entry.filename());
bool dataWillPersist = false;
--- a/security/manager/ssl/SSLServerCertVerification.cpp
+++ b/security/manager/ssl/SSLServerCertVerification.cpp
@@ -793,17 +793,17 @@ SSLServerCertVerificationJob::SSLServerC
uint32_t providerFlags,
Time time,
PRTime prtime)
: Runnable("psm::SSLServerCertVerificationJob")
, mCertVerifier(certVerifier)
, mFdForLogging(fdForLogging)
, mInfoObject(infoObject)
, mCert(CERT_DupCertificate(cert.get()))
- , mPeerCertChain(Move(peerCertChain))
+ , mPeerCertChain(std::move(peerCertChain))
, mProviderFlags(providerFlags)
, mTime(time)
, mPRTime(prtime)
, mJobStartTime(TimeStamp::Now())
, mStapledOCSPResponse(SECITEM_DupItem(stapledOCSPResponse))
, mSCTsFromTLSExtension(SECITEM_DupItem(sctsFromTLSExtension))
{
}
@@ -1460,27 +1460,27 @@ AuthCertificate(CertVerifier& certVerifi
evStatus = EVStatus::NotEV;
} else {
evStatus = EVStatus::EV;
}
RefPtr<nsNSSCertificate> nsc = nsNSSCertificate::Create(cert.get());
status->SetServerCert(nsc, evStatus);
- status->SetSucceededCertChain(Move(builtCertChain));
+ status->SetSucceededCertChain(std::move(builtCertChain));
MOZ_LOG(gPIPNSSLog, LogLevel::Debug,
("AuthCertificate setting NEW cert %p", nsc.get()));
status->SetCertificateTransparencyInfo(certificateTransparencyInfo);
}
if (rv != Success) {
// Certificate validation failed; store the peer certificate chain on
// infoObject so it can be used for error reporting.
- infoObject->SetFailedCertChain(Move(peerCertChain));
+ infoObject->SetFailedCertChain(std::move(peerCertChain));
PR_SetError(MapResultToPRErrorCode(rv), 0);
}
return rv == Success ? SECSuccess : SECFailure;
}
/*static*/ SECStatus
SSLServerCertVerificationJob::Dispatch(
@@ -1513,17 +1513,17 @@ SSLServerCertVerificationJob::Dispatch(
nsNSSCertList::DupCertList(peerCertChain);
if (!peerCertChainCopy) {
PR_SetError(SEC_ERROR_NO_MEMORY, 0);
return SECFailure;
}
RefPtr<SSLServerCertVerificationJob> job(
new SSLServerCertVerificationJob(certVerifier, fdForLogging, infoObject,
- serverCert, Move(peerCertChainCopy),
+ serverCert, std::move(peerCertChainCopy),
stapledOCSPResponse, sctsFromTLSExtension,
providerFlags, time, prtime));
nsresult nrv = gCertVerificationThreadPool->Dispatch(job, NS_DISPATCH_NORMAL);
if (NS_FAILED(nrv)) {
// We can't call SetCertVerificationResult here to change
// mCertVerificationState because SetCertVerificationResult will call
// libssl functions that acquire SSL locks that are already being held at
--- a/security/manager/ssl/SecretDecoderRing.cpp
+++ b/security/manager/ssl/SecretDecoderRing.cpp
@@ -45,17 +45,17 @@ void BackgroundSdrEncryptStrings(const n
break;
}
cipherTexts.AppendElement(NS_ConvertASCIItoUTF16(cipherText));
}
nsCOMPtr<nsIRunnable> runnable(
NS_NewRunnableFunction("BackgroundSdrEncryptStringsResolve",
- [rv, aPromise = Move(aPromise), cipherTexts = Move(cipherTexts)]() {
+ [rv, aPromise = std::move(aPromise), cipherTexts = std::move(cipherTexts)]() {
if (NS_FAILED(rv)) {
aPromise->MaybeReject(rv);
} else {
aPromise->MaybeResolve(cipherTexts);
}
}));
NS_DispatchToMainThread(runnable.forget());
}
@@ -165,17 +165,17 @@ SecretDecoderRing::AsyncEncryptStrings(u
}
InfallibleTArray<nsCString> plaintextsUtf8(plaintextsCount);
for (uint32_t i = 0; i < plaintextsCount; ++i) {
plaintextsUtf8.AppendElement(NS_ConvertUTF16toUTF8(plaintexts[i]));
}
nsCOMPtr<nsIRunnable> runnable(
NS_NewRunnableFunction("BackgroundSdrEncryptStrings",
- [promise, plaintextsUtf8 = Move(plaintextsUtf8)]() mutable {
+ [promise, plaintextsUtf8 = std::move(plaintextsUtf8)]() mutable {
BackgroundSdrEncryptStrings(plaintextsUtf8, promise);
}));
nsCOMPtr<nsIThread> encryptionThread;
nsresult rv = NS_NewNamedThread("AsyncSDRThread",
getter_AddRefs(encryptionThread),
runnable);
if (NS_WARN_IF(NS_FAILED(rv))) {
--- a/security/manager/ssl/TransportSecurityInfo.cpp
+++ b/security/manager/ssl/TransportSecurityInfo.cpp
@@ -507,14 +507,14 @@ TransportSecurityInfo::GetFailedCertChai
return NS_OK;
}
nsresult
TransportSecurityInfo::SetFailedCertChain(UniqueCERTCertList certList)
{
// nsNSSCertList takes ownership of certList
- mFailedCertChain = new nsNSSCertList(Move(certList));
+ mFailedCertChain = new nsNSSCertList(std::move(certList));
return NS_OK;
}
} } // namespace mozilla::psm
--- a/security/manager/ssl/nsCertOverrideService.h
+++ b/security/manager/ssl/nsCertOverrideService.h
@@ -78,18 +78,18 @@ class nsCertOverrideEntry final : public
typedef const char* KeyTypePointer;
// do nothing with aHost - we require mHead to be set before we're live!
explicit nsCertOverrideEntry(KeyTypePointer aHostWithPortUTF8)
{
}
nsCertOverrideEntry(nsCertOverrideEntry&& toMove)
- : mSettings(mozilla::Move(toMove.mSettings))
- , mHostWithPort(mozilla::Move(toMove.mHostWithPort))
+ : mSettings(std::move(toMove.mSettings))
+ , mHostWithPort(std::move(toMove.mHostWithPort))
{
}
~nsCertOverrideEntry()
{
}
KeyType GetKey() const
--- a/security/manager/ssl/nsClientAuthRemember.h
+++ b/security/manager/ssl/nsClientAuthRemember.h
@@ -60,18 +60,18 @@ class nsClientAuthRememberEntry final :
typedef const char* KeyTypePointer;
// do nothing with aHost - we require mHead to be set before we're live!
explicit nsClientAuthRememberEntry(KeyTypePointer aHostWithCertUTF8)
{
}
nsClientAuthRememberEntry(nsClientAuthRememberEntry&& aToMove)
- : mSettings(mozilla::Move(aToMove.mSettings))
- , mEntryKey(mozilla::Move(aToMove.mEntryKey))
+ : mSettings(std::move(aToMove.mSettings))
+ , mEntryKey(std::move(aToMove.mEntryKey))
{
}
~nsClientAuthRememberEntry()
{
}
KeyType GetKey() const
--- a/security/manager/ssl/nsNSSCallbacks.cpp
+++ b/security/manager/ssl/nsNSSCallbacks.cpp
@@ -120,17 +120,17 @@ OCSPRequest::OCSPRequest(const nsCString
const OriginAttributes& originAttributes,
Vector<uint8_t>&& ocspRequest,
TimeDuration timeout)
: mMonitor("OCSPRequest.mMonitor")
, mNotifiedDone(false)
, mLoader(nullptr)
, mAIALocation(aiaLocation)
, mOriginAttributes(originAttributes)
- , mPOSTData(Move(ocspRequest))
+ , mPOSTData(std::move(ocspRequest))
, mTimeout(timeout)
, mTimeoutTimer(nullptr)
, mStartTime()
, mResponseResult(NS_ERROR_FAILURE)
, mResponseBytes()
{
}
@@ -466,17 +466,17 @@ DoOCSPRequest(const nsCString& aiaLocati
return mozilla::pkix::Result::FATAL_ERROR_LIBRARY_FAILURE;
}
MOZ_ASSERT(!onSTSThread);
if (onSTSThread) {
return mozilla::pkix::Result::FATAL_ERROR_INVALID_STATE;
}
RefPtr<OCSPRequest> request(new OCSPRequest(aiaLocation, originAttributes,
- Move(ocspRequest), timeout));
+ std::move(ocspRequest), timeout));
rv = request->DispatchToMainThreadAndWait();
if (NS_FAILED(rv)) {
return mozilla::pkix::Result::FATAL_ERROR_LIBRARY_FAILURE;
}
rv = request->GetResponse(result);
if (NS_FAILED(rv)) {
if (rv == NS_ERROR_MALFORMED_URI) {
return mozilla::pkix::Result::ERROR_CERT_BAD_ACCESS_LOCATION;
@@ -1039,17 +1039,17 @@ DetermineEVAndCTStatusAndSetNewCert(RefP
} else {
MOZ_LOG(gPIPNSSLog, LogLevel::Debug,
("HandshakeCallback using NEW cert %p (is not EV)", nssc.get()));
sslStatus->SetServerCert(nssc, EVStatus::NotEV);
}
if (rv == Success) {
sslStatus->SetCertificateTransparencyInfo(certificateTransparencyInfo);
- sslStatus->SetSucceededCertChain(Move(builtChain));
+ sslStatus->SetSucceededCertChain(std::move(builtChain));
}
}
static nsresult
IsCertificateDistrustImminent(nsIX509CertList* aCertList,
/* out */ bool& isDistrusted) {
if (!aCertList) {
return NS_ERROR_INVALID_POINTER;
--- a/security/manager/ssl/nsNSSCertificate.cpp
+++ b/security/manager/ssl/nsNSSCertificate.cpp
@@ -838,17 +838,17 @@ NS_IMPL_CLASSINFO(nsNSSCertList,
NS_IMPL_ISUPPORTS_CI(nsNSSCertList,
nsIX509CertList,
nsISerializable)
nsNSSCertList::nsNSSCertList(UniqueCERTCertList certList)
{
if (certList) {
- mCertList = Move(certList);
+ mCertList = std::move(certList);
} else {
mCertList = UniqueCERTCertList(CERT_NewCertList());
}
}
nsNSSCertList::nsNSSCertList()
{
mCertList = UniqueCERTCertList(CERT_NewCertList());
--- a/security/manager/ssl/nsNSSCertificateDB.cpp
+++ b/security/manager/ssl/nsNSSCertificateDB.cpp
@@ -1147,17 +1147,17 @@ nsNSSCertificateDB::GetCerts(nsIX509Cert
}
nsCOMPtr<nsIInterfaceRequestor> ctx = new PipUIContext();
nsCOMPtr<nsIX509CertList> nssCertList;
UniqueCERTCertList certList(PK11_ListCerts(PK11CertListUnique, ctx));
// nsNSSCertList 1) adopts certList, and 2) handles the nullptr case fine.
// (returns an empty list)
- nssCertList = new nsNSSCertList(Move(certList));
+ nssCertList = new nsNSSCertList(std::move(certList));
nssCertList.forget(_retval);
return NS_OK;
}
NS_IMETHODIMP
nsNSSCertificateDB::GetEnterpriseRoots(nsIX509CertList** enterpriseRoots)
{
@@ -1233,17 +1233,17 @@ VerifyCertAtTime(nsIX509Cert* aCert,
nullptr, // stapledOCSPResponse
nullptr, // sctsFromTLSExtension
OriginAttributes(),
&evOidPolicy);
}
nsCOMPtr<nsIX509CertList> nssCertList;
// This adopts the list
- nssCertList = new nsNSSCertList(Move(resultChain));
+ nssCertList = new nsNSSCertList(std::move(resultChain));
NS_ENSURE_TRUE(nssCertList, NS_ERROR_FAILURE);
*_retval = mozilla::pkix::MapResultToPRErrorCode(result);
if (result == mozilla::pkix::Success && evOidPolicy != SEC_OID_UNKNOWN) {
*aHasEVPolicy = true;
}
nssCertList.forget(aVerifiedChain);
--- a/security/manager/ssl/nsNSSComponent.cpp
+++ b/security/manager/ssl/nsNSSComponent.cpp
@@ -515,17 +515,17 @@ nsNSSComponent::MaybeImportFamilySafetyR
}
// Looking for a certificate with the common name 'Microsoft Family Safety'
UniquePORTString subjectName(CERT_GetCommonName(&nssCertificate->subject));
MOZ_LOG(gPIPNSSLog, LogLevel::Debug,
("subject name is '%s'", subjectName.get()));
if (kMicrosoftFamilySafetyCN.Equals(subjectName.get())) {
wasFamilySafetyRoot = true;
MOZ_ASSERT(!mFamilySafetyRoot);
- mFamilySafetyRoot = Move(nssCertificate);
+ mFamilySafetyRoot = std::move(nssCertificate);
MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("added Family Safety root"));
}
return NS_OK;
}
// Because HCERTSTORE is just a typedef void*, we can't use any of the nice
// scoped or unique pointer templates. To elaborate, any attempt would
// instantiate those templates with T = void. When T gets used in the context
@@ -758,17 +758,17 @@ nsNSSComponent::GetEnterpriseRoots(nsIX5
return NS_OK;
}
UniqueCERTCertList enterpriseRootsCopy(
nsNSSCertList::DupCertList(mEnterpriseRoots));
if (!enterpriseRootsCopy) {
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsIX509CertList> enterpriseRootsCertList(
- new nsNSSCertList(Move(enterpriseRootsCopy)));
+ new nsNSSCertList(std::move(enterpriseRootsCopy)));
if (!enterpriseRootsCertList) {
return NS_ERROR_FAILURE;
}
enterpriseRootsCertList.forget(enterpriseRoots);
return NS_OK;
}
static const char* kEnterpriseRootModePref = "security.enterprise_roots.enabled";
@@ -1080,17 +1080,17 @@ nsNSSComponent::CheckForSmartCardChanges
// there's no thread safety concern here.
Vector<UniqueSECMODModule> modulesWithRemovableSlots;
{
AutoSECMODListReadLock secmodLock;
SECMODModuleList* list = SECMOD_GetDefaultModuleList();
while (list) {
if (SECMOD_HasRemovableSlots(list->module)) {
UniqueSECMODModule module(SECMOD_ReferenceModule(list->module));
- if (!modulesWithRemovableSlots.append(Move(module))) {
+ if (!modulesWithRemovableSlots.append(std::move(module))) {
return NS_ERROR_OUT_OF_MEMORY;
}
}
list = list->next;
}
}
for (auto& module : modulesWithRemovableSlots) {
// Best-effort.
@@ -1191,48 +1191,48 @@ LoadLoadableRootsTask::LoadLoadableRoots
// Prefer the application's installation directory,
// but also ensure the library is at least the version we expect.
Vector<nsCString> possibleCKBILocations;
// First try in the directory where we've already loaded
// DLL_PREFIX nss3 DLL_SUFFIX, since that's likely to be correct.
nsAutoCString nss3Dir;
nsresult rv = GetNSS3Directory(nss3Dir);
if (NS_SUCCEEDED(rv)) {
- if (!possibleCKBILocations.append(Move(nss3Dir))) {
+ if (!possibleCKBILocations.append(std::move(nss3Dir))) {
return NS_ERROR_OUT_OF_MEMORY;
}
} else {
// For some reason this fails on android. In any case, we should try with
// the other potential locations we have.
MOZ_LOG(gPIPNSSLog, LogLevel::Debug,
("could not determine where nss was loaded from"));
}
nsAutoCString currentProcessDir;
rv = GetDirectoryPath(NS_XPCOM_CURRENT_PROCESS_DIR, currentProcessDir);
if (NS_SUCCEEDED(rv)) {
- if (!possibleCKBILocations.append(Move(currentProcessDir))) {
+ if (!possibleCKBILocations.append(std::move(currentProcessDir))) {
return NS_ERROR_OUT_OF_MEMORY;
}
} else {
MOZ_LOG(gPIPNSSLog, LogLevel::Debug,
("could not get current process directory"));
}
nsAutoCString greDir;
rv = GetDirectoryPath(NS_GRE_DIR, greDir);
if (NS_SUCCEEDED(rv)) {
- if (!possibleCKBILocations.append(Move(greDir))) {
+ if (!possibleCKBILocations.append(std::move(greDir))) {
return NS_ERROR_OUT_OF_MEMORY;
}
} else {
MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("could not get gre directory"));
}
// As a last resort, this will cause the library loading code to use the OS'
// default library search path.
nsAutoCString emptyString;
- if (!possibleCKBILocations.append(Move(emptyString))) {
+ if (!possibleCKBILocations.append(std::move(emptyString))) {
return NS_ERROR_OUT_OF_MEMORY;
}
for (const auto& possibleCKBILocation : possibleCKBILocations) {
if (mozilla::psm::LoadLoadableRoots(possibleCKBILocation)) {
MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("loaded CKBI from %s",
possibleCKBILocation.get()));
return NS_OK;
--- a/security/manager/ssl/nsNSSIOLayer.cpp
+++ b/security/manager/ssl/nsNSSIOLayer.cpp
@@ -2312,17 +2312,17 @@ ClientAuthDataRunnable::RunOnTargetThrea
}
if (PR_GetError() == SEC_ERROR_BAD_PASSWORD) {
// problem with password: bail
goto loser;
}
}
if (!cert && lowPrioNonrepCert) {
- cert = Move(lowPrioNonrepCert);
+ cert = std::move(lowPrioNonrepCert);
privKey.reset(PK11_FindKeyByAnyCert(cert.get(), wincx));
}
if (!cert) {
goto loser;
}
} else { // Not Auto => ask
// Get the SSL Certificate
--- a/security/manager/ssl/nsPKCS12Blob.cpp
+++ b/security/manager/ssl/nsPKCS12Blob.cpp
@@ -297,17 +297,17 @@ nsPKCS12Blob::newPKCS12FilePassword(uint
bool pressedOK = false;
rv = certDialogs->SetPKCS12FilePassword(mUIContext, password, &pressedOK);
if (NS_FAILED(rv)) {
return rv;
}
if (!pressedOK) {
return NS_OK;
}
- passwordBuffer = Move(stringToBigEndianBytes(password, passwordBufferLength));
+ passwordBuffer = std::move(stringToBigEndianBytes(password, passwordBufferLength));
return NS_OK;
}
// Launch a dialog requesting the user for the password to a PKCS#12 file.
// Handle user canceled by returning null password (caller must catch).
nsresult
nsPKCS12Blob::getPKCS12FilePassword(uint32_t& passwordBufferLength,
UniquePtr<uint8_t[]>& passwordBuffer)
@@ -323,17 +323,17 @@ nsPKCS12Blob::getPKCS12FilePassword(uint
bool pressedOK = false;
rv = certDialogs->GetPKCS12FilePassword(mUIContext, password, &pressedOK);
if (NS_FAILED(rv)) {
return rv;
}
if (!pressedOK) {
return NS_OK;
}
- passwordBuffer = Move(stringToBigEndianBytes(password, passwordBufferLength));
+ passwordBuffer = std::move(stringToBigEndianBytes(password, passwordBufferLength));
return NS_OK;
}
// Given a decoder, read bytes from file and input them to the decoder.
nsresult
nsPKCS12Blob::inputToDecoder(UniqueSEC_PKCS12DecoderContext& dcx, nsIFile* file,
PRErrorCode& nssError)
{
--- a/security/manager/ssl/nsSSLStatus.cpp
+++ b/security/manager/ssl/nsSSLStatus.cpp
@@ -395,17 +395,17 @@ nsSSLStatus::SetServerCert(nsNSSCertific
mIsEV = (aEVStatus == EVStatus::EV);
mHasIsEVStatus = true;
}
nsresult
nsSSLStatus::SetSucceededCertChain(UniqueCERTCertList aCertList)
{
// nsNSSCertList takes ownership of certList
- mSucceededCertChain = new nsNSSCertList(Move(aCertList));
+ mSucceededCertChain = new nsNSSCertList(std::move(aCertList));
return NS_OK;
}
void
nsSSLStatus::SetFailedCertChain(nsIX509CertList* aX509CertList)
{
mFailedCertChain = aX509CertList;
--- a/security/manager/ssl/nsSiteSecurityService.cpp
+++ b/security/manager/ssl/nsSiteSecurityService.cpp
@@ -1131,17 +1131,17 @@ nsSiteSecurityService::ProcessPKPHeader(
false, // don't store intermediates
flags,
aOriginAttributes)
!= mozilla::pkix::Success) {
return NS_ERROR_FAILURE;
}
// This copy to produce an nsNSSCertList should also be removed in Bug #1406854
- nsCOMPtr<nsIX509CertList> x509CertList = new nsNSSCertList(Move(certList));
+ nsCOMPtr<nsIX509CertList> x509CertList = new nsNSSCertList(std::move(certList));
if (!x509CertList) {
return rv;
}
RefPtr<nsNSSCertList> nssCertList = x509CertList->GetCertList();
nsCOMPtr<nsIX509Cert> rootCert;
rv = nssCertList->GetRootCertificate(rootCert);
if (NS_FAILED(rv)) {
--- a/security/manager/ssl/tests/unit/tlsserver/lib/TLSServer.cpp
+++ b/security/manager/ssl/tests/unit/tlsserver/lib/TLSServer.cpp
@@ -477,17 +477,17 @@ ConfigSecureServerWithNamedCert(PRFileDe
if (SSL_ConfigSecureServerWithCertChain(fd, cert.get(), certList.get(),
key.get(), certKEA) != SECSuccess) {
PrintPRError("SSL_ConfigSecureServer failed");
return SECFailure;
}
if (certOut) {
- *certOut = Move(cert);
+ *certOut = std::move(cert);
}
if (keaOut) {
*keaOut = certKEA;
}
SSL_OptionSet(fd, SSL_NO_CACHE, false);
SSL_OptionSet(fd, SSL_ENABLE_SESSION_TICKETS, true);
--- a/security/sandbox/linux/Sandbox.cpp
+++ b/security/sandbox/linux/Sandbox.cpp
@@ -625,17 +625,17 @@ SetContentProcessSandbox(ContentProcessS
gSandboxReporterClient = new SandboxReporterClient(procType);
// This needs to live until the process exits.
static SandboxBrokerClient* sBroker;
if (brokerFd >= 0) {
sBroker = new SandboxBrokerClient(brokerFd);
}
- SetCurrentProcessSandbox(GetContentSandboxPolicy(sBroker, Move(aParams)));
+ SetCurrentProcessSandbox(GetContentSandboxPolicy(sBroker, std::move(aParams)));
return true;
}
#endif // MOZ_CONTENT_SANDBOX
#ifdef MOZ_GMP_SANDBOX
/**
* Starts the seccomp sandbox for a media plugin process. Should be
* called only once, and before any potentially harmful content is
@@ -661,17 +661,17 @@ SetMediaPluginSandbox(const char *aFileP
SandboxOpenedFile plugin(aFilePath);
if (!plugin.IsOpen()) {
SANDBOX_LOG_ERROR("failed to open plugin file %s: %s",
aFilePath, strerror(errno));
MOZ_CRASH();
}
auto files = new SandboxOpenedFiles();
- files->Add(Move(plugin));
+ files->Add(std::move(plugin));
files->Add("/dev/urandom", true);
files->Add("/sys/devices/system/cpu/cpu0/tsc_freq_khz");
files->Add("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq");
files->Add("/proc/cpuinfo"); // Info also available via CPUID instruction.
#ifdef __i386__
files->Add("/proc/self/auxv"); // Info also in process's address space.
#endif
--- a/security/sandbox/linux/SandboxFilter.cpp
+++ b/security/sandbox/linux/SandboxFilter.cpp
@@ -380,17 +380,17 @@ private:
ContentProcessSandboxParams mParams;
bool mAllowSysV;
bool mUsingRenderDoc;
bool BelowLevel(int aLevel) const {
return mParams.mLevel < aLevel;
}
ResultExpr AllowBelowLevel(int aLevel, ResultExpr aOrElse) const {
- return BelowLevel(aLevel) ? Allow() : Move(aOrElse);
+ return BelowLevel(aLevel) ? Allow() : std::move(aOrElse);
}
ResultExpr AllowBelowLevel(int aLevel) const {
return AllowBelowLevel(aLevel, InvalidSyscall());
}
// Returns true if the running kernel supports separate syscalls for
// socket operations, or false if it supports only socketcall(2).
static bool
@@ -738,17 +738,17 @@ private:
reinterpret_cast<AddrPtr>(innerArgs[1]),
static_cast<socklen_t>(innerArgs[2]));
}
public:
ContentSandboxPolicy(SandboxBrokerClient* aBroker,
ContentProcessSandboxParams&& aParams)
: mBroker(aBroker)
- , mParams(Move(aParams))
+ , mParams(std::move(aParams))
, mAllowSysV(PR_GetEnv("MOZ_SANDBOX_ALLOW_SYSV") != nullptr)
, mUsingRenderDoc(PR_GetEnv("RENDERDOC_CAPTUREOPTS") != nullptr)
{ }
~ContentSandboxPolicy() override = default;
Maybe<ResultExpr> EvaluateSocketCall(int aCall, bool aHasArgs) const override {
switch(aCall) {
@@ -1220,17 +1220,17 @@ public:
}
}
};
UniquePtr<sandbox::bpf_dsl::Policy>
GetContentSandboxPolicy(SandboxBrokerClient* aMaybeBroker,
ContentProcessSandboxParams&& aParams)
{
- return MakeUnique<ContentSandboxPolicy>(aMaybeBroker, Move(aParams));
+ return MakeUnique<ContentSandboxPolicy>(aMaybeBroker, std::move(aParams));
}
#endif // MOZ_CONTENT_SANDBOX
#ifdef MOZ_GMP_SANDBOX
// Unlike for content, the GeckoMediaPlugin seccomp-bpf policy needs
// to be an effective sandbox by itself, because we allow GMP on Linux
// systems where that's the only sandboxing mechanism we can use.
--- a/security/sandbox/linux/SandboxOpenedFiles.cpp
+++ b/security/sandbox/linux/SandboxOpenedFiles.cpp
@@ -12,17 +12,17 @@
#include <fcntl.h>
#include <unistd.h>
namespace mozilla {
// The default move constructor almost works, but Atomic isn't
// move-constructable and the fd needs some special handling.
SandboxOpenedFile::SandboxOpenedFile(SandboxOpenedFile&& aMoved)
-: mPath(Move(aMoved.mPath))
+: mPath(std::move(aMoved.mPath))
, mMaybeFd(aMoved.TakeDesc())
, mDup(aMoved.mDup)
, mExpectError(aMoved.mExpectError)
{ }
SandboxOpenedFile::SandboxOpenedFile(const char* aPath, bool aDup)
: mPath(aPath), mDup(aDup), mExpectError(false)
{
--- a/security/sandbox/linux/broker/SandboxBroker.cpp
+++ b/security/sandbox/linux/broker/SandboxBroker.cpp
@@ -37,17 +37,17 @@
namespace mozilla {
// Default/fallback temporary directory
static const nsLiteralCString tempDirPrefix("/tmp");
// This constructor signals failure by setting mFileDesc and aClientFd to -1.
SandboxBroker::SandboxBroker(UniquePtr<const Policy> aPolicy, int aChildPid,
int& aClientFd)
- : mChildPid(aChildPid), mPolicy(Move(aPolicy))
+ : mChildPid(aChildPid), mPolicy(std::move(aPolicy))
{
int fds[2];
if (0 != socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC, 0, fds)) {
SANDBOX_LOG_ERROR("SandboxBroker: socketpair failed: %s", strerror(errno));
mFileDesc = -1;
aClientFd = -1;
return;
}
@@ -65,24 +65,24 @@ SandboxBroker::SandboxBroker(UniquePtr<c
}
UniquePtr<SandboxBroker>
SandboxBroker::Create(UniquePtr<const Policy> aPolicy, int aChildPid,
ipc::FileDescriptor& aClientFdOut)
{
int clientFd;
// Can't use MakeUnique here because the constructor is private.
- UniquePtr<SandboxBroker> rv(new SandboxBroker(Move(aPolicy), aChildPid,
+ UniquePtr<SandboxBroker> rv(new SandboxBroker(std::move(aPolicy), aChildPid,
clientFd));
if (clientFd < 0) {
rv = nullptr;
} else {
aClientFdOut = ipc::FileDescriptor(clientFd);
}
- return Move(rv);
+ return std::move(rv);
}
SandboxBroker::~SandboxBroker() {
// If the constructor failed, there's nothing to be done here.
if (mFileDesc < 0) {
return;
}
--- a/security/sandbox/linux/gtest/TestBroker.cpp
+++ b/security/sandbox/linux/gtest/TestBroker.cpp
@@ -131,17 +131,17 @@ SandboxBrokerTest::GetPolicy() const
policy->AddPath(MAY_READ, "/var/empty/qwertyuiop", AddAlways);
policy->AddPath(MAY_ACCESS, "/proc/self", AddAlways); // Warning: Linux-specific.
policy->AddPath(MAY_READ | MAY_WRITE, "/tmp", AddAlways);
policy->AddPath(MAY_READ | MAY_WRITE | MAY_CREATE, "/tmp/blublu", AddAlways);
policy->AddPath(MAY_READ | MAY_WRITE | MAY_CREATE, "/tmp/blublublu", AddAlways);
// This should be non-writable by the user running the test:
policy->AddPath(MAY_READ | MAY_WRITE, "/etc", AddAlways);
- return Move(policy);
+ return std::move(policy);
}
TEST_F(SandboxBrokerTest, OpenForRead)
{
int fd;
fd = Open("/dev/null", O_RDONLY);
ASSERT_GE(fd, 0) << "Opening /dev/null failed.";
--- a/security/sandbox/linux/launch/SandboxLaunch.cpp
+++ b/security/sandbox/linux/launch/SandboxLaunch.cpp
@@ -321,17 +321,17 @@ SandboxLaunchPrepare(GeckoProcessType aT
default:
// Nothing yet.
break;
}
if (canChroot || flags != 0) {
auto forker = MakeUnique<SandboxFork>(flags | CLONE_NEWUSER, canChroot);
forker->PrepareMapping(&aOptions->fds_to_remap);
- aOptions->fork_delegate = Move(forker);
+ aOptions->fork_delegate = std::move(forker);
if (canChroot) {
aOptions->env_map[kSandboxChrootEnvFlag] = "1";
}
}
}
SandboxFork::SandboxFork(int aFlags, bool aChroot)
: mFlags(aFlags)
--- a/security/sandbox/linux/reporter/SandboxReporter.cpp
+++ b/security/sandbox/linux/reporter/SandboxReporter.cpp
@@ -288,12 +288,12 @@ SandboxReporter::GetSnapshot()
const SandboxReport* rep = &mBuffer[i % kSandboxReporterBufferSize];
MOZ_ASSERT(rep->IsValid());
snapshot.mReports.AppendElement(*rep);
}
// Named Return Value Optimization would apply here, but C++11
// doesn't require it; so, instead of possibly copying the entire
// array contents, invoke the move constructor and copy at most a
// few words.
- return Move(snapshot);
+ return std::move(snapshot);
}
} // namespace mozilla
--- a/security/sandbox/linux/reporter/SandboxReporterWrappers.cpp
+++ b/security/sandbox/linux/reporter/SandboxReporterWrappers.cpp
@@ -126,17 +126,17 @@ NS_IMETHODIMP SandboxReportWrapper::GetA
class SandboxReportArray final : public mozISandboxReportArray
{
public:
NS_DECL_ISUPPORTS
NS_DECL_MOZISANDBOXREPORTARRAY
explicit SandboxReportArray(SandboxReporter::Snapshot&& aSnap)
: mOffset(aSnap.mOffset)
- , mArray(Move(aSnap.mReports))
+ , mArray(std::move(aSnap.mReports))
{ }
private:
~SandboxReportArray() = default;
uint64_t mOffset;
nsTArray<SandboxReport> mArray;
};
--- a/startupcache/StartupCache.cpp
+++ b/startupcache/StartupCache.cpp
@@ -323,17 +323,17 @@ StartupCache::PutBuffer(const char* id,
#ifdef DEBUG
if (mArchive) {
nsZipItem* zipItem = mArchive->GetItem(id);
NS_ASSERTION(zipItem == nullptr, "Existing entry in disk StartupCache.");
}
#endif
entry.OrInsert([&inbuf, &len]() {
- return new CacheEntry(Move(inbuf), len);
+ return new CacheEntry(std::move(inbuf), len);
});
mPendingWrites.AppendElement(idStr);
return ResetStartupWriteTimer();
}
size_t
StartupCache::SizeOfMapping()
{
--- a/startupcache/StartupCache.h
+++ b/startupcache/StartupCache.h
@@ -74,17 +74,17 @@ namespace scache {
struct CacheEntry
{
UniquePtr<char[]> data;
uint32_t size;
CacheEntry() : size(0) { }
// Takes possession of buf
- CacheEntry(UniquePtr<char[]> buf, uint32_t len) : data(Move(buf)), size(len) { }
+ CacheEntry(UniquePtr<char[]> buf, uint32_t len) : data(std::move(buf)), size(len) { }
~CacheEntry()
{
}
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) {
return mallocSizeOf(this) + mallocSizeOf(data.get());
}
--- a/startupcache/StartupCacheUtils.cpp
+++ b/startupcache/StartupCacheUtils.cpp
@@ -93,17 +93,17 @@ NewBufferFromStorageStream(nsIStorageStr
if (NS_SUCCEEDED(rv) && avail != read)
rv = NS_ERROR_UNEXPECTED;
if (NS_FAILED(rv)) {
return rv;
}
*len = avail;
- *buffer = Move(temp);
+ *buffer = std::move(temp);
return NS_OK;
}
static const char baseName[2][5] = { "gre/", "app/" };
static inline bool
canonicalizeBase(nsAutoCString &spec,
nsACString &out)
--- a/startupcache/test/TestStartupCache.cpp
+++ b/startupcache/test/TestStartupCache.cpp
@@ -172,26 +172,26 @@ TEST_F(TestStartupCache, WriteObject)
EXPECT_TRUE(NS_SUCCEEDED(rv));
UniquePtr<char[]> buf;
uint32_t len;
NewBufferFromStorageStream(storageStream, &buf, &len);
// Since this is a post-startup write, it should be written and
// available.
- rv = sc->PutBuffer(id, Move(buf), len);
+ rv = sc->PutBuffer(id, std::move(buf), len);
EXPECT_TRUE(NS_SUCCEEDED(rv));
UniquePtr<char[]> buf2;
uint32_t len2;
nsCOMPtr<nsIObjectInputStream> objectInput;
rv = sc->GetBuffer(id, &buf2, &len2);
EXPECT_TRUE(NS_SUCCEEDED(rv));
- rv = NewObjectInputStreamFromBuffer(Move(buf2), len2,
+ rv = NewObjectInputStreamFromBuffer(std::move(buf2), len2,
getter_AddRefs(objectInput));
EXPECT_TRUE(NS_SUCCEEDED(rv));
nsCOMPtr<nsISupports> deserialized;
rv = objectInput->ReadObject(true, getter_AddRefs(deserialized));
EXPECT_TRUE(NS_SUCCEEDED(rv));
nsCOMPtr<nsIURI> uri(do_QueryInterface(deserialized));
--- a/toolkit/components/backgroundhangmonitor/BackgroundHangMonitor.cpp
+++ b/toolkit/components/backgroundhangmonitor/BackgroundHangMonitor.cpp
@@ -486,40 +486,40 @@ void
BackgroundHangThread::ReportHang(TimeDuration aHangTime)
{
// Recovered from a hang; called on the monitor thread
// mManager->mLock IS locked
nsTArray<HangAnnotation> annotations;
for (auto& annotation : mAnnotations) {
HangAnnotation annot(annotation.mName, annotation.mValue);
- annotations.AppendElement(mozilla::Move(annot));
+ annotations.AppendElement(std::move(annot));
}
HangDetails hangDetails(
aHangTime,
nsDependentCString(XRE_ChildProcessTypeToString(XRE_GetProcessType())),
VoidString(),
mThreadName,
mRunnableName,
- Move(mHangStack),
- Move(annotations)
+ std::move(mHangStack),
+ std::move(annotations)
);
// If the hang processing thread exists, we can process the native stack
// on it. Otherwise, we are unable to report a native stack, so we just
// report without one.
if (mManager->mHangProcessingThread) {
nsCOMPtr<nsIRunnable> processHangStackRunnable =
- new ProcessHangStackRunnable(Move(hangDetails));
+ new ProcessHangStackRunnable(std::move(hangDetails));
mManager->mHangProcessingThread
->Dispatch(processHangStackRunnable.forget());
} else {
NS_WARNING("Unable to report native stack without a BHR processing thread");
- RefPtr<nsHangDetails> hd = new nsHangDetails(Move(hangDetails));
+ RefPtr<nsHangDetails> hd = new nsHangDetails(std::move(hangDetails));
hd->Submit();
}
// If the profiler is enabled, add a marker.
#ifdef MOZ_GECKO_PROFILER
if (profiler_is_active()) {
TimeStamp endTime = TimeStamp::Now();
TimeStamp startTime = endTime - aHangTime;
--- a/toolkit/components/backgroundhangmonitor/HangDetails.cpp
+++ b/toolkit/components/backgroundhangmonitor/HangDetails.cpp
@@ -377,15 +377,15 @@ ReadModuleInformation(HangStack& stack)
NS_IMETHODIMP
ProcessHangStackRunnable::Run()
{
// NOTE: Reading module information can take a long time, which is why we do
// it off-main-thread.
ReadModuleInformation(mHangDetails.stack());
- RefPtr<nsHangDetails> hangDetails = new nsHangDetails(Move(mHangDetails));
+ RefPtr<nsHangDetails> hangDetails = new nsHangDetails(std::move(mHangDetails));
hangDetails->Submit();
return NS_OK;
}
} // namespace mozilla
--- a/toolkit/components/backgroundhangmonitor/HangDetails.h
+++ b/toolkit/components/backgroundhangmonitor/HangDetails.h
@@ -26,17 +26,17 @@ namespace mozilla {
*/
class nsHangDetails : public nsIHangDetails
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIHANGDETAILS
explicit nsHangDetails(HangDetails&& aDetails)
- : mDetails(Move(aDetails))
+ : mDetails(std::move(aDetails))
{}
// Submit these HangDetails to the main thread. This will dispatch a runnable
// to the main thread which will fire off the bhr-thread-hang observer
// notification with this HangDetails as the subject.
void Submit();
private:
@@ -53,17 +53,17 @@ private:
* This object should have the only remaining reference to aHangDetails, as it
* will access its fields without synchronization.
*/
class ProcessHangStackRunnable final : public Runnable
{
public:
explicit ProcessHangStackRunnable(HangDetails&& aHangDetails)
: Runnable("ProcessHangStackRunnable")
- , mHangDetails(Move(aHangDetails))
+ , mHangDetails(std::move(aHangDetails))
{}
NS_IMETHOD Run() override;
private:
HangDetails mHangDetails;
};
--- a/toolkit/components/backgroundhangmonitor/ThreadStackHelper.cpp
+++ b/toolkit/components/backgroundhangmonitor/ThreadStackHelper.cpp
@@ -186,17 +186,17 @@ ThreadStackHelper::TryAppendFrame(HangEn
}
// Record that we _want_ to use another frame entry. If this exceeds
// mMaxStackSize, we'll allocate more room on the next hang.
mDesiredStackSize += 1;
// Perform the append if we have enough space to do so.
if (mStackToFill->stack().Capacity() > mStackToFill->stack().Length()) {
- mStackToFill->stack().AppendElement(mozilla::Move(aFrame));
+ mStackToFill->stack().AppendElement(std::move(aFrame));
}
}
void
ThreadStackHelper::CollectNativeLeafAddr(void* aAddr)
{
MOZ_RELEASE_ASSERT(mStackToFill);
TryAppendFrame(HangEntryProgCounter(reinterpret_cast<uintptr_t>(aAddr)));
--- a/toolkit/components/extensions/MatchGlob.h
+++ b/toolkit/components/extensions/MatchGlob.h
@@ -80,17 +80,17 @@ private:
class MatchGlobSet final : public nsTArray<RefPtr<MatchGlob>>
{
public:
// Note: We can't use the nsTArray constructors directly, since the static
// analyzer doesn't handle their MOZ_IMPLICIT annotations correctly.
MatchGlobSet() {}
explicit MatchGlobSet(size_type aCapacity) : nsTArray(aCapacity) {}
explicit MatchGlobSet(const nsTArray& aOther) : nsTArray(aOther) {}
- MOZ_IMPLICIT MatchGlobSet(nsTArray&& aOther) : nsTArray(mozilla::Move(aOther)) {}
+ MOZ_IMPLICIT MatchGlobSet(nsTArray&& aOther) : nsTArray(std::move(aOther)) {}
MOZ_IMPLICIT MatchGlobSet(std::initializer_list<RefPtr<MatchGlob>> aIL) : nsTArray(aIL) {}
bool Matches(const nsAString& aValue) const;
};
} // namespace extensions
} // namespace mozilla
--- a/toolkit/components/extensions/MatchPattern.cpp
+++ b/toolkit/components/extensions/MatchPattern.cpp
@@ -540,22 +540,22 @@ MatchPatternSet::Constructor(dom::Global
patterns.AppendElement(elem.GetAsMatchPattern());
} else {
RefPtr<MatchPattern> pattern = MatchPattern::Constructor(
aGlobal, elem.GetAsString(), aOptions, aRv);
if (!pattern) {
return nullptr;
}
- patterns.AppendElement(Move(pattern));
+ patterns.AppendElement(std::move(pattern));
}
}
RefPtr<MatchPatternSet> patternSet = new MatchPatternSet(aGlobal.GetAsSupports(),
- Move(patterns));
+ std::move(patterns));
return patternSet.forget();
}
bool
MatchPatternSet::Matches(const nsAString& aURL, bool aExplicit, ErrorResult& aRv) const
{
nsCOMPtr<nsIURI> uri;
--- a/toolkit/components/extensions/WebExtensionPolicy.cpp
+++ b/toolkit/components/extensions/WebExtensionPolicy.cpp
@@ -100,17 +100,17 @@ WebExtensionPolicy::WebExtensionPolicy(G
return;
}
RefPtr<WebExtensionContentScript> contentScript =
new WebExtensionContentScript(*this, scriptInit, aRv);
if (aRv.Failed()) {
return;
}
- mContentScripts.AppendElement(Move(contentScript));
+ mContentScripts.AppendElement(std::move(contentScript));
}
nsresult rv = NS_NewURI(getter_AddRefs(mBaseURI), aInit.mBaseURL);
if (NS_FAILED(rv)) {
aRv.Throw(rv);
}
}
@@ -232,17 +232,17 @@ WebExtensionPolicy::RegisterContentScrip
// the expected extension or if it is already registered.
if (script.mExtension != this || mContentScripts.Contains(&script)) {
aRv.Throw(NS_ERROR_INVALID_ARG);
return;
}
RefPtr<WebExtensionContentScript> newScript = &script;
- if (!mContentScripts.AppendElement(Move(newScript), fallible)) {
+ if (!mContentScripts.AppendElement(std::move(newScript), fallible)) {
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
return;
}
WebExtensionPolicyBinding::ClearCachedContentScriptsValue(this);
}
void
--- a/toolkit/components/extensions/webrequest/ChannelWrapper.cpp
+++ b/toolkit/components/extensions/webrequest/ChannelWrapper.cpp
@@ -851,17 +851,17 @@ ChannelWrapper::GetProxyInfo(dom::Nullab
}
if (proxyInfo) {
MozProxyInfo result;
nsresult rv = FillProxyInfo(result, proxyInfo);
if (NS_FAILED(rv)) {
aRv.Throw(rv);
} else {
- aRetVal.SetValue(Move(result));
+ aRetVal.SetValue(std::move(result));
}
}
}
void
ChannelWrapper::GetRemoteAddress(nsCString& aRetVal) const
{
aRetVal.SetIsVoid(true);
--- a/toolkit/components/extensions/webrequest/StreamFilter.cpp
+++ b/toolkit/components/extensions/webrequest/StreamFilter.cpp
@@ -88,32 +88,32 @@ StreamFilter::Connect()
ContentChild* cc = ContentChild::GetSingleton();
if (cc) {
RefPtr<StreamFilter> self(this);
cc->SendInitStreamFilter(mChannelId, addonId)->Then(
GetCurrentThreadSerialEventTarget(),
__func__,
[=] (mozilla::ipc::Endpoint<PStreamFilterChild>&& aEndpoint) {
- self->FinishConnect(Move(aEndpoint));
+ self->FinishConnect(std::move(aEndpoint));
},
[=] (mozilla::ipc::ResponseRejectReason aReason) {
self->mActor->RecvInitialized(false);
});
} else {
mozilla::ipc::Endpoint<PStreamFilterChild> endpoint;
Unused << StreamFilterParent::Create(nullptr, mChannelId, addonId, &endpoint);
// Always dispatch asynchronously so JS callers have a chance to attach
// event listeners before we dispatch events.
NS_DispatchToCurrentThread(
NewRunnableMethod<mozilla::ipc::Endpoint<PStreamFilterChild>&&>(
"StreamFilter::FinishConnect",
this, &StreamFilter::FinishConnect,
- Move(endpoint)));
+ std::move(endpoint)));
}
}
void
StreamFilter::FinishConnect(mozilla::ipc::Endpoint<PStreamFilterChild>&& aEndpoint)
{
if (aEndpoint.IsValid()) {
MOZ_RELEASE_ASSERT(aEndpoint.Bind(mActor));
@@ -172,17 +172,17 @@ StreamFilter::Write(const ArrayBufferOrU
} else if (aData.IsUint8Array()) {
ok = ReadTypedArrayData(data, aData.GetAsUint8Array(), aRv);
} else {
MOZ_ASSERT_UNREACHABLE("Argument should be ArrayBuffer or Uint8Array");
return;
}
if (ok) {
- mActor->Write(Move(data), aRv);
+ mActor->Write(std::move(data), aRv);
}
}
StreamFilterStatus
StreamFilter::Status() const
{
if (!mActor) {
return StreamFilterStatus::Uninitialized;
--- a/toolkit/components/extensions/webrequest/StreamFilterBase.h
+++ b/toolkit/components/extensions/webrequest/StreamFilterBase.h
@@ -16,25 +16,25 @@ namespace extensions {
class StreamFilterBase
{
public:
typedef nsTArray<uint8_t> Data;
protected:
class BufferedData : public LinkedListElement<BufferedData> {
public:
- explicit BufferedData(Data&& aData) : mData(Move(aData)) {}
+ explicit BufferedData(Data&& aData) : mData(std::move(aData)) {}
Data mData;
};
LinkedList<BufferedData> mBufferedData;
inline void
BufferData(Data&& aData) {
- mBufferedData.insertBack(new BufferedData(Move(aData)));
+ mBufferedData.insertBack(new BufferedData(std::move(aData)));
};
};
} // namespace extensions
} // namespace mozilla
#endif // mozilla_extensions_StreamFilterBase_h
--- a/toolkit/components/extensions/webrequest/StreamFilterChild.cpp
+++ b/toolkit/components/extensions/webrequest/StreamFilterChild.cpp
@@ -375,17 +375,17 @@ StreamFilterChild::Write(Data&& aData, E
case State::FinishedTransferringData:
break;
default:
aRv.Throw(NS_ERROR_FAILURE);
return;
}
- SendWrite(Move(aData));
+ SendWrite(std::move(aData));
}
StreamFilterStatus
StreamFilterChild::Status() const
{
switch (mState) {
case State::Uninitialized:
case State::Initialized:
@@ -517,21 +517,21 @@ StreamFilterChild::RecvData(Data&& aData
case State::FinishedTransferringData:
MOZ_ASSERT_UNREACHABLE("Received data in unexpected state");
EmitData(aData);
break;
case State::Suspending:
case State::Suspended:
- BufferData(Move(aData));
+ BufferData(std::move(aData));
break;
case State::Disconnecting:
- SendWrite(Move(aData));
+ SendWrite(std::move(aData));
break;
case State::Closing:
break;
default:
MOZ_ASSERT_UNREACHABLE("Received data in unexpected state");
return IPC_FAIL_NO_REASON(this);
--- a/toolkit/components/extensions/webrequest/StreamFilterParent.cpp
+++ b/toolkit/components/extensions/webrequest/StreamFilterParent.cpp
@@ -55,17 +55,17 @@ private:
nsCOMPtr<nsIEventTarget> mTarget;
};
class ChannelEventFunction final : public ChannelEventWrapper
{
public:
ChannelEventFunction(nsIEventTarget* aTarget, std::function<void()>&& aFunc)
: ChannelEventWrapper(aTarget)
- , mFunc(Move(aFunc))
+ , mFunc(std::move(aFunc))
{}
void Run() override
{
mFunc();
}
protected:
@@ -146,34 +146,34 @@ StreamFilterParent::Create(dom::ContentP
Endpoint<PStreamFilterParent> parent;
Endpoint<PStreamFilterChild> child;
nsresult rv = PStreamFilter::CreateEndpoints(channelPid,
aContentParent ? aContentParent->OtherPid()
: base::GetCurrentProcId(),
&parent, &child);
NS_ENSURE_SUCCESS(rv, false);
- if (!chan->AttachStreamFilter(Move(parent))) {
+ if (!chan->AttachStreamFilter(std::move(parent))) {
return false;
}
- *aEndpoint = Move(child);
+ *aEndpoint = std::move(child);
return true;
}
/* static */ void
StreamFilterParent::Attach(nsIChannel* aChannel, ParentEndpoint&& aEndpoint)
{
auto self = MakeRefPtr<StreamFilterParent>();
self->ActorThread()->Dispatch(
NewRunnableMethod<ParentEndpoint&&>("StreamFilterParent::Bind",
self,
&StreamFilterParent::Bind,
- Move(aEndpoint)),
+ std::move(aEndpoint)),
NS_DISPATCH_NORMAL);
self->Init(aChannel);
// IPC owns this reference now.
Unused << self.forget();
}
@@ -377,17 +377,17 @@ IPCResult
StreamFilterParent::RecvWrite(Data&& aData)
{
AssertIsActorThread();
RunOnIOThread(
NewRunnableMethod<Data&&>("StreamFilterParent::WriteMove",
this,
&StreamFilterParent::WriteMove,
- Move(aData)));
+ std::move(aData)));
return IPC_OK();
}
void
StreamFilterParent::WriteMove(Data&& aData)
{
nsresult rv = Write(aData);
Unused << NS_WARN_IF(NS_FAILED(rv));
@@ -528,17 +528,17 @@ StreamFilterParent::OnStartRequest(nsIRe
nsresult rv = mOrigListener->OnStartRequest(aRequest, aContext);
// Important: Do this only *after* running the next listener in the chain, so
// that we get the final delivery target after any retargeting that it may do.
if (nsCOMPtr<nsIThreadRetargetableRequest> req = do_QueryInterface(aRequest)) {
nsCOMPtr<nsIEventTarget> thread;
Unused << req->GetDeliveryTarget(getter_AddRefs(thread));
if (thread) {
- mIOThread = Move(thread);
+ mIOThread = std::move(thread);
}
}
// Important: Do this *after* we have set the thread delivery target, or it is
// possible in rare circumstances for an extension to attempt to write data
// before the thread has been set up, even though there are several layers of
// asynchrony involved.
if (!mDisconnected) {
@@ -637,25 +637,25 @@ StreamFilterParent::OnDataAvailable(nsIR
uint32_t count;
nsresult rv = aInputStream->Read(reinterpret_cast<char*>(data.Elements()),
aCount, &count);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(count == aCount, NS_ERROR_UNEXPECTED);
if (mState == State::Disconnecting) {
MutexAutoLock al(mBufferMutex);
- BufferData(Move(data));
+ BufferData(std::move(data));
} else if (mState == State::Closed) {
return NS_ERROR_FAILURE;
} else {
ActorThread()->Dispatch(
NewRunnableMethod<Data&&>("StreamFilterParent::DoSendData",
this,
&StreamFilterParent::DoSendData,
- Move(data)),
+ std::move(data)),
NS_DISPATCH_NORMAL);
}
return NS_OK;
}
nsresult
StreamFilterParent::FlushBufferedData()
{
@@ -725,36 +725,36 @@ StreamFilterParent::AssertIsIOThread()
{
MOZ_ASSERT(IsIOThread());
}
template<typename Function>
void
StreamFilterParent::RunOnMainThread(const char* aName, Function&& aFunc)
{
- mQueue->RunOrEnqueue(new ChannelEventFunction(mMainThread, Move(aFunc)));
+ mQueue->RunOrEnqueue(new ChannelEventFunction(mMainThread, std::move(aFunc)));
}
void
StreamFilterParent::RunOnMainThread(already_AddRefed<Runnable> aRunnable)
{
- mQueue->RunOrEnqueue(new ChannelEventRunnable(mMainThread, Move(aRunnable)));
+ mQueue->RunOrEnqueue(new ChannelEventRunnable(mMainThread, std::move(aRunnable)));
}
template<typename Function>
void
StreamFilterParent::RunOnIOThread(const char* aName, Function&& aFunc)
{
- mQueue->RunOrEnqueue(new ChannelEventFunction(mIOThread, Move(aFunc)));
+ mQueue->RunOrEnqueue(new ChannelEventFunction(mIOThread, std::move(aFunc)));
}
void
StreamFilterParent::RunOnIOThread(already_AddRefed<Runnable> aRunnable)
{
- mQueue->RunOrEnqueue(new ChannelEventRunnable(mIOThread, Move(aRunnable)));
+ mQueue->RunOrEnqueue(new ChannelEventRunnable(mIOThread, std::move(aRunnable)));
}
template<typename Function>
void
StreamFilterParent::RunOnActorThread(const char* aName, Function&& aFunc)
{
// We don't use mQueue for dispatch to the actor thread.
//
@@ -770,17 +770,17 @@ StreamFilterParent::RunOnActorThread(con
//
// The actor thread, however, is always a serial event target. Its events are
// always processed in order, and events dispatched to the actor thread are
// independent of the events in the output event queue.
if (IsActorThread()) {
aFunc();
} else {
ActorThread()->Dispatch(
- Move(NS_NewRunnableFunction(aName, aFunc)),
+ std::move(NS_NewRunnableFunction(aName, aFunc)),
NS_DISPATCH_NORMAL);
}
}
/*****************************************************************************
* Glue
*****************************************************************************/
--- a/toolkit/components/extensions/webrequest/WebRequestService.cpp
+++ b/toolkit/components/extensions/webrequest/WebRequestService.cpp
@@ -42,17 +42,17 @@ UniquePtr<WebRequestChannelEntry>
WebRequestService::RegisterChannel(ChannelWrapper* aChannel)
{
UniquePtr<ChannelEntry> entry(new ChannelEntry(aChannel));
auto key = mChannelEntries.LookupForAdd(entry->mChannelId);
MOZ_DIAGNOSTIC_ASSERT(!key);
key.OrInsert([&entry]() { return entry.get(); });
- return Move(entry);
+ return std::move(entry);
}
already_AddRefed<nsITraceableChannel>
WebRequestService::GetTraceableChannel(uint64_t aChannelId,
nsAtom* aAddonId,
nsIContentParent* aContentParent)
{
--- a/toolkit/components/osfile/NativeOSFileInternals.cpp
+++ b/toolkit/components/osfile/NativeOSFileInternals.cpp
@@ -922,17 +922,17 @@ public:
const nsAString& aTmpPath,
const nsAString& aBackupTo,
const bool aFlush,
const bool aNoOverwrite,
nsMainThreadPtrHandle<nsINativeOSFileSuccessCallback>& aOnSuccess,
nsMainThreadPtrHandle<nsINativeOSFileErrorCallback>& aOnError)
: AbstractDoEvent(aOnSuccess, aOnError)
, mPath(aPath)
- , mBuffer(Move(aBuffer))
+ , mBuffer(std::move(aBuffer))
, mBytes(aBytes)
, mTmpPath(aTmpPath)
, mBackupTo(aBackupTo)
, mFlush(aFlush)
, mNoOverwrite(aNoOverwrite)
, mResult(new Int32Result(TimeStamp::Now()))
{
MOZ_ASSERT(NS_IsMainThread());
@@ -1292,17 +1292,17 @@ NativeOSFileInternalsService::WriteAtomi
new nsMainThreadPtrHolder<nsINativeOSFileSuccessCallback>(
"nsINativeOSFileSuccessCallback", onSuccess));
nsCOMPtr<nsINativeOSFileErrorCallback> onError(aOnError);
nsMainThreadPtrHandle<nsINativeOSFileErrorCallback> onErrorHandle(
new nsMainThreadPtrHolder<nsINativeOSFileErrorCallback>(
"nsINativeOSFileErrorCallback", onError));
RefPtr<AbstractDoEvent> event = new DoWriteAtomicEvent(aPath,
- Move(buffer),
+ std::move(buffer),
bytes,
dict.mTmpPath,
dict.mBackupTo,
dict.mFlush,
dict.mNoOverwrite,
onSuccessHandle,
onErrorHandle);
nsresult rv;
--- a/toolkit/components/perfmonitoring/nsPerformanceStats.cpp
+++ b/toolkit/components/perfmonitoring/nsPerformanceStats.cpp
@@ -1300,17 +1300,17 @@ nsPerformanceStatsService::GetResources(
return NS_OK;
}
void
nsPerformanceStatsService::NotifyJankObservers(const mozilla::Vector<uint64_t>& aPreviousJankLevels) {
// The move operation is generally constant time, unless
// `mPendingAlerts.length()` is very small, in which case it's fast anyway.
- GroupVector alerts(Move(mPendingAlerts));
+ GroupVector alerts(std::move(mPendingAlerts));
mPendingAlerts = GroupVector(); // Reconstruct after `Move`.
if (!mPendingAlertsCollector) {
// We are shutting down.
return;
}
// Find out if we have noticed any user-noticeable delay in an
--- a/toolkit/components/places/History.cpp
+++ b/toolkit/components/places/History.cpp
@@ -689,17 +689,17 @@ public:
if (mIsVisited) {
History* history = History::GetService();
NS_ENSURE_STATE(history);
history->NotifyVisited(mURI);
AutoTArray<URIParams, 1> uris;
URIParams uri;
SerializeURI(mURI, uri);
- uris.AppendElement(Move(uri));
+ uris.AppendElement(std::move(uri));
history->NotifyVisitedParent(uris);
}
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
if (observerService) {
nsAutoString status;
if (mIsVisited) {
@@ -847,27 +847,27 @@ public:
if (mPlaces.Length() > 0) {
InfallibleTArray<URIParams> serializableUris(mPlaces.Length());
for (uint32_t i = 0; i < mPlaces.Length(); ++i) {
nsresult rv = NotifyVisit(navHistory, obsService, now, uris[i], mPlaces[i]);
NS_ENSURE_SUCCESS(rv, rv);
URIParams serializedUri;
SerializeURI(uris[i], serializedUri);
- serializableUris.AppendElement(Move(serializedUri));
+ serializableUris.AppendElement(std::move(serializedUri));
}
mHistory->NotifyVisitedParent(serializableUris);
} else {
AutoTArray<URIParams, 1> serializableUris;
nsresult rv = NotifyVisit(navHistory, obsService, now, uris[0], mPlace);
NS_ENSURE_SUCCESS(rv, rv);
URIParams serializedUri;
SerializeURI(uris[0], serializedUri);
- serializableUris.AppendElement(Move(serializedUri));
+ serializableUris.AppendElement(std::move(serializedUri));
mHistory->NotifyVisitedParent(serializableUris);
}
return NS_OK;
}
private:
nsTArray<VisitData> mPlaces;
VisitData mPlace;
--- a/toolkit/components/protobuf/src/google/protobuf/map_entry_lite.h
+++ b/toolkit/components/protobuf/src/google/protobuf/map_entry_lite.h
@@ -55,35 +55,35 @@ class MapFieldLite;
namespace protobuf {
namespace internal {
// MoveHelper::Move is used to set *dest. It copies *src, or moves it (in
// the C++11 sense), or swaps it. *src is left in a sane state for
// subsequent destruction, but shouldn't be used for anything.
template <bool is_enum, bool is_message, bool is_stringlike, typename T>
struct MoveHelper { // primitives
- static void Move(T* src, T* dest) { *dest = *src; }
+ static void std::move(T* src, T* dest) { *dest = *src; }
};
template <bool is_message, bool is_stringlike, typename T>
struct MoveHelper<true, is_message, is_stringlike, T> { // enums
- static void Move(T* src, T* dest) { *dest = *src; }
+ static void std::move(T* src, T* dest) { *dest = *src; }
// T is an enum here, so allow conversions to and from int.
- static void Move(T* src, int* dest) { *dest = static_cast<int>(*src); }
- static void Move(int* src, T* dest) { *dest = static_cast<T>(*src); }
+ static void std::move(T* src, int* dest) { *dest = static_cast<int>(*src); }
+ static void std::move(int* src, T* dest) { *dest = static_cast<T>(*src); }
};
template <bool is_stringlike, typename T>
struct MoveHelper<false, true, is_stringlike, T> { // messages
- static void Move(T* src, T* dest) { dest->Swap(src); }
+ static void std::move(T* src, T* dest) { dest->Swap(src); }
};
template <typename T>
struct MoveHelper<false, false, true, T> { // strings and similar
- static void Move(T* src, T* dest) {
+ static void std::move(T* src, T* dest) {
#if __cplusplus >= 201103L
*dest = std::move(*src);
#else
dest->swap(*src);
#endif
}
};
--- a/toolkit/components/reputationservice/LoginReputation.cpp
+++ b/toolkit/components/reputationservice/LoginReputation.cpp
@@ -145,17 +145,17 @@ LoginWhitelist::QueryLoginWhitelist(nsIL
// AsyncClassifyLocalWithTables API won't trigger a gethash request on
// a full-length match, so this API call should only include local operation.
rv = uriClassifier->AsyncClassifyLocalWithTables(uri, mTables, this);
if (NS_FAILED(rv)) {
return p;
}
fail.release();
- mQueryPromises.AppendElement(Move(holder));
+ mQueryPromises.AppendElement(std::move(holder));
return p;
}
nsresult
LoginWhitelist::OnClassifyComplete(nsresult aErrorCode,
const nsACString& aLists,
const nsACString& aProvider,
const nsACString& aFullHash)
@@ -164,17 +164,17 @@ LoginWhitelist::OnClassifyComplete(nsres
if (gShuttingDown) {
return NS_OK;
}
LR_LOG(("OnClassifyComplete : list = %s", aLists.BeginReading()));
UniquePtr<MozPromiseHolder<ReputationPromise>> holder =
- Move(mQueryPromises.ElementAt(0));
+ std::move(mQueryPromises.ElementAt(0));
mQueryPromises.RemoveElementAt(0);
if (NS_FAILED(aErrorCode)) {
// This should not happen
MOZ_ASSERT_UNREACHABLE("unexpected error received in OnClassifyComplete");
holder->Reject(aErrorCode, __func__);
} else if (aLists.IsEmpty()) {
// Reject if we can not find url in white list.
--- a/toolkit/components/telemetry/HangReports.cpp
+++ b/toolkit/components/telemetry/HangReports.cpp
@@ -61,17 +61,17 @@ HangReports::AddHang(const Telemetry::Pr
if (annotationsEntry) {
// If the key is already in the hash map, append the index of the chrome hang
// to its indices.
annotationsEntry->mHangIndices.AppendElement(hangIndex);
return;
}
// If the key was not found, add the annotations to the hash map.
- mAnnotationInfo.Put(annotationsKey, new AnnotationInfo(hangIndex, Move(aAnnotations)));
+ mAnnotationInfo.Put(annotationsKey, new AnnotationInfo(hangIndex, std::move(aAnnotations)));
}
/**
* This function removes links to discarded chrome hangs stacks and prunes unused
* annotations.
*/
void
HangReports::PruneStackReferences(const size_t aRemovedStackIndex) {
--- a/toolkit/components/telemetry/HangReports.h
+++ b/toolkit/components/telemetry/HangReports.h
@@ -24,29 +24,29 @@ class HangReports {
public:
/**
* This struct encapsulates information for an individual ChromeHang annotation.
* mHangIndex is the index of the corresponding ChromeHang.
*/
struct AnnotationInfo {
AnnotationInfo(uint32_t aHangIndex,
HangMonitor::HangAnnotations&& aAnnotations)
- : mAnnotations(Move(aAnnotations))
+ : mAnnotations(std::move(aAnnotations))
{
mHangIndices.AppendElement(aHangIndex);
}
AnnotationInfo(AnnotationInfo&& aOther)
: mHangIndices(aOther.mHangIndices)
- , mAnnotations(Move(aOther.mAnnotations))
+ , mAnnotations(std::move(aOther.mAnnotations))
{}
~AnnotationInfo() = default;
AnnotationInfo& operator=(AnnotationInfo&& aOther)
{
mHangIndices = aOther.mHangIndices;
- mAnnotations = Move(aOther.mAnnotations);
+ mAnnotations = std::move(aOther.mAnnotations);
return *this;
}
// To save memory, a single AnnotationInfo can be associated to multiple chrome
// hangs. The following array holds the index of each related chrome hang.
nsTArray<uint32_t> mHangIndices;
HangMonitor::HangAnnotations mAnnotations;
private:
--- a/toolkit/components/telemetry/Telemetry.cpp
+++ b/toolkit/components/telemetry/Telemetry.cpp
@@ -1596,17 +1596,17 @@ TelemetryImpl::RecordChromeHang(uint32_t
{
if (!sTelemetry || !TelemetryHistogram::CanRecordExtended())
return;
MutexAutoLock hangReportMutex(sTelemetry->mHangReportsMutex);
sTelemetry->mHangReports.AddHang(aStack, aDuration,
aSystemUptime, aFirefoxUptime,
- Move(aAnnotations));
+ std::move(aAnnotations));
}
void
TelemetryImpl::DoStackCapture(const nsACString& aKey) {
if (Telemetry::CanRecordExtended() && XRE_IsParentProcess()) {
sTelemetry->mStackCapturer.Capture(aKey);
}
}
@@ -2163,17 +2163,17 @@ void Init()
void RecordChromeHang(uint32_t duration,
ProcessedStack &aStack,
int32_t aSystemUptime,
int32_t aFirefoxUptime,
HangAnnotations&& aAnnotations)
{
TelemetryImpl::RecordChromeHang(duration, aStack,
aSystemUptime, aFirefoxUptime,
- Move(aAnnotations));
+ std::move(aAnnotations));
}
void CaptureStack(const nsACString& aKey)
{
#ifdef MOZ_GECKO_PROFILER
TelemetryImpl::DoStackCapture(aKey);
#endif
}
--- a/toolkit/components/telemetry/TelemetryEvent.cpp
+++ b/toolkit/components/telemetry/TelemetryEvent.cpp
@@ -1146,17 +1146,17 @@ TelemetryEvent::CreateSnapshots(uint32_t
const EventRecord& record = (*eventStorage)[i];
if (IsInDataset(GetDataset(locker, record.GetEventKey()), aDataset)) {
events.AppendElement(record);
}
}
if (events.Length()) {
const char* processName = GetNameForProcessID(ProcessID(iter.Key()));
- processEvents.AppendElement(mozilla::MakePair(processName, Move(events)));
+ processEvents.AppendElement(mozilla::MakePair(processName, std::move(events)));
}
}
};
// Take a snapshot of the plain and dynamic builtin events.
snapshotter(gEventRecords);
if (aClear) {
--- a/toolkit/components/telemetry/TelemetryHistogram.cpp
+++ b/toolkit/components/telemetry/TelemetryHistogram.cpp
@@ -1069,17 +1069,17 @@ KeyedHistogram::GetSnapshot(const Static
}
HistogramSnapshotData keySnapshot;
if (NS_FAILED(internal_GetHistogramAndSamples(aLock, keyData, keySnapshot))) {
return NS_ERROR_FAILURE;
}
// Append to the final snapshot.
- aSnapshot.Put(iter.Get()->GetKey(), mozilla::Move(keySnapshot));
+ aSnapshot.Put(iter.Get()->GetKey(), std::move(keySnapshot));
}
if (aClearSubsession) {
Clear();
}
return NS_OK;
}
@@ -1139,17 +1139,17 @@ internal_GetKeyedHistogramsSnapshot(cons
}
// Take a snapshot of the keyed histogram data!
KeyedHistogramSnapshotData snapshot;
if (!NS_SUCCEEDED(keyed->GetSnapshot(aLock, snapshot, aClearSubsession))) {
return NS_ERROR_FAILURE;
}
- if (!hArray.emplaceBack(KeyedHistogramSnapshotInfo{mozilla::Move(snapshot), id})) {
+ if (!hArray.emplaceBack(KeyedHistogramSnapshotInfo{std::move(snapshot), id})) {
return NS_ERROR_OUT_OF_MEMORY;
}
}
}
return NS_OK;
}
} // namespace
@@ -2904,17 +2904,17 @@ TelemetryHistogram::DeserializeHistogram
nsCString histogramName;
if (NS_FAILED(internal_ParseHistogramData(aCx, histogram, processDataObj,
histogramName, deserializedCounts, sum))) {
continue;
}
// Finally append the deserialized data to the storage.
if (!deserializedProcessData.emplaceBack(
- MakeTuple(mozilla::Move(histogramName), mozilla::Move(deserializedCounts), sum))) {
+ MakeTuple(std::move(histogramName), std::move(deserializedCounts), sum))) {
return NS_ERROR_OUT_OF_MEMORY;
}
}
}
// Update the histogram storage.
{
StaticMutexAutoLock locker(gTelemetryHistogramMutex);
@@ -2949,17 +2949,17 @@ TelemetryHistogram::DeserializeHistogram
size_t numCounts = mozilla::Get<1>(histogramData).Length();
if (h->bucket_count() != numCounts) {
MOZ_ASSERT(false,
"The number of restored buckets does not match with the on in the definition");
continue;
}
// Update the data for the histogram.
- h->AddSampleSet(base::PersistedSampleSet(mozilla::Move(mozilla::Get<1>(histogramData)),
+ h->AddSampleSet(base::PersistedSampleSet(std::move(mozilla::Get<1>(histogramData)),
mozilla::Get<2>(histogramData)));
}
}
}
return NS_OK;
}
@@ -3085,18 +3085,18 @@ TelemetryHistogram::DeserializeKeyedHist
nsCString keyName;
if (NS_FAILED(internal_ParseHistogramData(aCx, key, keysDataObj, keyName,
deserializedCounts, sum))) {
continue;
}
// Finally append the deserialized data to the storage.
if (!deserializedProcessData.emplaceBack(
- MakeTuple(nsCString(NS_ConvertUTF16toUTF8(histogramName)), mozilla::Move(keyName),
- mozilla::Move(deserializedCounts), sum))) {
+ MakeTuple(nsCString(NS_ConvertUTF16toUTF8(histogramName)), std::move(keyName),
+ std::move(deserializedCounts), sum))) {
return NS_ERROR_OUT_OF_MEMORY;
}
}
}
}
// Update the keyed histogram storage.
{
@@ -3143,16 +3143,16 @@ TelemetryHistogram::DeserializeKeyedHist
size_t numCounts = mozilla::Get<2>(histogramData).Length();
if (h->bucket_count() != numCounts) {
MOZ_ASSERT(false,
"The number of restored buckets does not match with the on in the definition");
continue;
}
// Update the data for the histogram.
- h->AddSampleSet(base::PersistedSampleSet(mozilla::Move(mozilla::Get<2>(histogramData)),
+ h->AddSampleSet(base::PersistedSampleSet(std::move(mozilla::Get<2>(histogramData)),
mozilla::Get<3>(histogramData)));
}
}
}
return NS_OK;
}
--- a/toolkit/components/telemetry/geckoview/TelemetryGeckoViewPersistence.cpp
+++ b/toolkit/components/telemetry/geckoview/TelemetryGeckoViewPersistence.cpp
@@ -376,17 +376,17 @@ PersistenceThreadPersist()
mozilla::MakeUnique<StreamingJSONWriter>();
if (!jsonWriter || NS_FAILED(jsonWriter->Open(persistenceFile))) {
ANDROID_LOG("PersistenceThreadPersist - There was an error opening the persistence file.");
return;
}
// Build the JSON structure: give up the ownership of jsonWriter.
- mozilla::JSONWriter w(mozilla::Move(jsonWriter));
+ mozilla::JSONWriter w(std::move(jsonWriter));
w.Start();
w.StartObjectProperty("scalars");
if (NS_FAILED(TelemetryScalar::SerializeScalars(w))) {
ANDROID_LOG("Persist - Failed to persist scalars.");
}
w.EndObject();
--- a/toolkit/components/telemetry/ipc/TelemetryIPCAccumulator.cpp
+++ b/toolkit/components/telemetry/ipc/TelemetryIPCAccumulator.cpp
@@ -356,11 +356,11 @@ TelemetryIPCAccumulator::DeInitializeGlo
gChildScalarsActions = nullptr;
gChildKeyedScalarsActions = nullptr;
gChildEvents = nullptr;
}
void
TelemetryIPCAccumulator::DispatchToMainThread(already_AddRefed<nsIRunnable>&& aEvent)
{
- SystemGroup::EventTargetFor(TaskCategory::Other)->Dispatch(Move(aEvent),
+ SystemGroup::EventTargetFor(TaskCategory::Other)->Dispatch(std::move(aEvent),
nsIEventTarget::DISPATCH_NORMAL);
}
--- a/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
+++ b/toolkit/components/url-classifier/nsUrlClassifierDBService.cpp
@@ -900,17 +900,17 @@ nsUrlClassifierDBServiceWorker::CacheCom
pParse->ForgetTableUpdates();
} else {
LOG(("Completion received, but table %s is not active, so not caching.",
result->table.get()));
}
}
mClassifier->ApplyFullHashes(&updates);
- mLastResults = Move(resultsPtr);
+ mLastResults = std::move(resultsPtr);
return NS_OK;
}
nsresult
nsUrlClassifierDBServiceWorker::CacheResultToTableUpdate(CacheResult* aCacheResult,
TableUpdate* aUpdate)
{
auto tuV2 = TableUpdate::Cast<TableUpdateV2>(aUpdate);
--- a/toolkit/components/url-classifier/tests/gtest/Common.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/Common.cpp
@@ -192,10 +192,10 @@ SetupLookupCache(const _PrefixArray& pre
UniquePtr<T> cache = MakeUnique<T>(GTEST_TABLE, EmptyCString(), file);
nsresult rv = cache->Init();
EXPECT_EQ(rv, NS_OK);
rv = BuildCache(cache.get(), prefixArray);
EXPECT_EQ(rv, NS_OK);
- return Move(cache);
+ return std::move(cache);
}
--- a/toolkit/components/url-classifier/tests/gtest/TestClassifier.cpp
+++ b/toolkit/components/url-classifier/tests/gtest/TestClassifier.cpp
@@ -17,17 +17,17 @@ GetClassifier()
{
nsCOMPtr<nsIFile> file;
NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(file));
UniquePtr<Classifier> classifier = MakeUnique<Classifier>();
nsresult rv = classifier->Open(*file);
EXPECT_TRUE(rv == NS_OK);
- return Move(classifier);
+ return std::move(classifier);
}
static nsresult
SetupLookupCacheV4(Classifier* classifier,
const _PrefixArray& aPrefixArray,
const nsACString& aTable)
{
LookupCacheV4* lookupCache =
--- a/toolkit/crashreporter/nsExceptionHandler.cpp
+++ b/toolkit/crashreporter/nsExceptionHandler.cpp
@@ -3789,17 +3789,17 @@ NotifyDumpResult(bool aResult,
{
std::function<void()> runnable = [&](){
aCallback(aResult);
};
if (aAsync) {
MOZ_ASSERT(!!aCallbackThread);
Unused << aCallbackThread->Dispatch(NS_NewRunnableFunction("CrashReporter::InvokeCallback",
- Move(runnable)),
+ std::move(runnable)),
NS_DISPATCH_SYNC);
} else {
runnable();
}
}
static void
CreatePairedChildMinidumpAsync(ProcessHandle aTargetPid,
@@ -3827,41 +3827,41 @@ CreatePairedChildMinidumpAsync(ProcessHa
targetThread,
aDumpPath,
PairedDumpCallbackExtra,
static_cast<void*>(&targetMinidump)
#ifdef XP_WIN32
, GetMinidumpType()
#endif
)) {
- NotifyDumpResult(false, aAsync, Move(aCallback), Move(aCallbackThread));
+ NotifyDumpResult(false, aAsync, std::move(aCallback), std::move(aCallbackThread));
return;
}
nsCOMPtr<nsIFile> targetExtra;
GetExtraFileForMinidump(targetMinidump, getter_AddRefs(targetExtra));
if (!targetExtra) {
targetMinidump->Remove(false);
- NotifyDumpResult(false, aAsync, Move(aCallback), Move(aCallbackThread));
+ NotifyDumpResult(false, aAsync, std::move(aCallback), std::move(aCallbackThread));
return;
}
RenameAdditionalHangMinidump(aIncomingDumpToPair,
targetMinidump,
aIncomingPairName);
if (ShouldReport()) {
MoveToPending(targetMinidump, targetExtra, nullptr);
MoveToPending(aIncomingDumpToPair, nullptr, nullptr);
}
targetMinidump.forget(aMainDumpOut);
- NotifyDumpResult(true, aAsync, Move(aCallback), Move(aCallbackThread));
+ NotifyDumpResult(true, aAsync, std::move(aCallback), std::move(aCallbackThread));
}
void
CreateMinidumpsAndPair(ProcessHandle aTargetPid,
ThreadId aTargetBlamedThread,
const nsACString& aIncomingPairName,
nsIFile* aIncomingDumpToPair,
nsIFile** aMainDumpOut,
@@ -3909,37 +3909,37 @@ CreateMinidumpsAndPair(ProcessHandle aTa
if (aAsync &&
!sMinidumpWriterThread &&
NS_FAILED(NS_NewNamedThread("Minidump Writer", &sMinidumpWriterThread))) {
aCallback(false);
return;
}
nsCString incomingPairName(aIncomingPairName);
- std::function<void(bool)> callback = Move(aCallback);
+ std::function<void(bool)> callback = std::move(aCallback);
// Don't call do_GetCurrentThread() if this is called synchronously because
// 1. it's unnecessary, and 2. more importantly, it might create one if called
// from a native thread, and the thread will be leaked.
RefPtr<nsIThread> callbackThread = aAsync ? do_GetCurrentThread() : nullptr;
std::function<void()> doDump = [=]() mutable {
CreatePairedChildMinidumpAsync(aTargetPid,
aTargetBlamedThread,
incomingPairName,
incomingDumpToPair,
aMainDumpOut,
dump_path,
- Move(callback),
- Move(callbackThread),
+ std::move(callback),
+ std::move(callbackThread),
aAsync);
};
if (aAsync) {
sMinidumpWriterThread->Dispatch(NS_NewRunnableFunction("CrashReporter::CreateMinidumpsAndPair",
- Move(doDump)),
+ std::move(doDump)),
nsIEventTarget::DISPATCH_NORMAL);
} else {
doDump();
}
}
bool
CreateAdditionalChildMinidump(ProcessHandle childPid,
--- a/toolkit/mozapps/extensions/AddonManagerStartup-inlines.h
+++ b/toolkit/mozapps/extensions/AddonManagerStartup-inlines.h
@@ -25,17 +25,17 @@ class PropertyIterElem;
template<class T, class PropertyType>
class MOZ_STACK_CLASS BaseIter {
public:
typedef T SelfType;
PropertyType begin() const
{
PropertyType elem(Self());
- return Move(elem);
+ return std::move(elem);
}
PropertyType end() const
{
PropertyType elem(Self());
return elem.End();
}
@@ -105,17 +105,17 @@ public:
return &mIter != &other.mIter || mIndex != other.mIndex;
}
SelfType End() const
{
SelfType end(mIter);
end.mIndex = Length();
- return Move(end);
+ return std::move(end);
}
void* Context() const { return mIter.Context(); }
protected:
const SelfType& Self() const
{
return *static_cast<const SelfType*>(this);
--- a/toolkit/mozapps/extensions/AddonManagerStartup.cpp
+++ b/toolkit/mozapps/extensions/AddonManagerStartup.cpp
@@ -207,17 +207,17 @@ GetJarCache()
MOZ_TRY(ios->GetProtocolHandler("jar", getter_AddRefs(jarProto)));
nsCOMPtr<nsIJARProtocolHandler> jar = do_QueryInterface(jarProto);
MOZ_ASSERT(jar);
nsCOMPtr<nsIZipReaderCache> zipCache;
MOZ_TRY(jar->GetJARCache(getter_AddRefs(zipCache)));
- return Move(zipCache);
+ return std::move(zipCache);
}
static Result<FileLocation, nsresult>
GetFileLocation(nsIURI* uri)
{
FileLocation location;
nsCOMPtr<nsIFileURL> fileURL = do_QueryInterface(uri);
@@ -238,17 +238,17 @@ GetFileLocation(nsIURI* uri)
MOZ_TRY(fileURL->GetFile(getter_AddRefs(file)));
nsCString entry;
MOZ_TRY(jarURI->GetJAREntry(entry));
location.Init(file, entry.get());
}
- return Move(location);
+ return std::move(location);
}
/*****************************************************************************
* JSON data handling
*****************************************************************************/
class MOZ_STACK_CLASS WrapperBase {
@@ -429,24 +429,24 @@ private:
Result<nsCOMPtr<nsIFile>, nsresult>
Addon::FullPath()
{
nsString path = Path();
// First check for an absolute path, in case we have a proxy file.
nsCOMPtr<nsIFile> file;
if (NS_SUCCEEDED(NS_NewLocalFile(path, false, getter_AddRefs(file)))) {
- return Move(file);
+ return std::move(file);
}
// If not an absolute path, fall back to a relative path from the location.
MOZ_TRY(NS_NewLocalFile(mLocation.Path(), false, getter_AddRefs(file)));
MOZ_TRY(file->AppendRelativePath(path));
- return Move(file);
+ return std::move(file);
}
Result<bool, nsresult>
Addon::UpdateLastModifiedTime()
{
nsCOMPtr<nsIFile> file;
MOZ_TRY_VAR(file, FullPath());
@@ -669,18 +669,18 @@ public:
NS_DECL_ISUPPORTS
NS_DECL_NSIJSRAIIHELPER
using Override = AutoTArray<nsCString, 2>;
using Locale = AutoTArray<nsCString, 3>;
RegistryEntries(FileLocation& location, nsTArray<Override>&& overrides, nsTArray<Locale>&& locales)
: mLocation(location)
- , mOverrides(Move(overrides))
- , mLocales(Move(locales))
+ , mOverrides(std::move(overrides))
+ , mLocales(std::move(locales))
{}
void Register();
protected:
virtual ~RegistryEntries()
{
Unused << Destruct();
@@ -790,18 +790,18 @@ AddonManagerStartup::RegisterChrome(nsIU
nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
NS_ENSURE_TRUE(obs, NS_ERROR_UNEXPECTED);
obs->AddObserver(this, "chrome-manifests-loaded", false);
sObserverRegistered = true;
}
auto entry = MakeRefPtr<RegistryEntries>(location,
- Move(overrides),
- Move(locales));
+ std::move(overrides),
+ std::move(locales));
entry->Register();
GetRegistryEntries().insertBack(entry);
entry.forget(result);
return NS_OK;
}
--- a/toolkit/xre/CmdLineAndEnvUtils.h
+++ b/toolkit/xre/CmdLineAndEnvUtils.h
@@ -339,17 +339,17 @@ MakeCommandLine(int argc, wchar_t **argv
if (i + 1 != argc) {
*c = ' ';
++c;
}
}
*c = '\0';
- return Move(s);
+ return std::move(s);
}
#endif // defined(XP_WIN)
// Save literal putenv string to environment variable.
inline void
SaveToEnv(const char *aEnvString)
{
--- a/toolkit/xre/nsAppRunner.cpp
+++ b/toolkit/xre/nsAppRunner.cpp
@@ -3798,17 +3798,17 @@ static void SetShutdownChecks() {
namespace mozilla {
namespace startup {
Result<nsCOMPtr<nsIFile>, nsresult>
GetIncompleteStartupFile(nsIFile* aProfLD)
{
nsCOMPtr<nsIFile> crashFile;
MOZ_TRY(aProfLD->Clone(getter_AddRefs(crashFile)));
MOZ_TRY(crashFile->Append(FILE_STARTUP_INCOMPLETE));
- return Move(crashFile);
+ return std::move(crashFile);
}
}
}
// Check whether the last startup attempt resulted in a crash within the
// last 6 hours.
// Note that this duplicates the logic in nsAppStartup::TrackStartupCrashBegin,
// which runs too late for our purposes.
--- a/tools/profiler/core/ProfileBufferEntry.cpp
+++ b/tools/profiler/core/ProfileBufferEntry.cpp
@@ -120,34 +120,34 @@ public:
const char* location, const Maybe<unsigned>& lineno) override
{
TypeInfo info = {
keyedBy ? Some(nsCString(keyedBy)) : Nothing(),
name ? Some(nsCString(name)) : Nothing(),
location ? Some(nsCString(location)) : Nothing(),
lineno
};
- mTypesetForUpcomingEntry.AppendElement(Move(info));
+ mTypesetForUpcomingEntry.AppendElement(std::move(info));
}
void operator()(JS::TrackedTypeSite site, const char* mirType) override
{
- nsTArray<TypeInfo> typeset(Move(mTypesetForUpcomingEntry));
+ nsTArray<TypeInfo> typeset(std::move(mTypesetForUpcomingEntry));
mLambda(site, mirType, typeset);
}
private:
nsTArray<TypeInfo> mTypesetForUpcomingEntry;
LambdaT mLambda;
};
template<typename LambdaT> ForEachTrackedOptimizationTypeInfoLambdaOp<LambdaT>
MakeForEachTrackedOptimizationTypeInfoLambdaOp(LambdaT&& aLambda)
{
- return ForEachTrackedOptimizationTypeInfoLambdaOp<LambdaT>(Move(aLambda));
+ return ForEachTrackedOptimizationTypeInfoLambdaOp<LambdaT>(std::move(aLambda));
}
// As mentioned in ProfileBufferEntry.h, the JSON format contains many
// arrays whose elements are laid out according to various schemas to help
// de-duplication. This RAII class helps write these arrays by keeping track of
// the last non-null element written and adding the appropriate number of null
// elements when writing new non-null elements. It also automatically opens and
// closes an array element on the given JSON writer.
@@ -225,29 +225,29 @@ private:
};
template<typename LambdaT>
class ForEachTrackedOptimizationAttemptsLambdaOp
: public JS::ForEachTrackedOptimizationAttemptOp
{
public:
explicit ForEachTrackedOptimizationAttemptsLambdaOp(LambdaT&& aLambda)
- : mLambda(Move(aLambda))
+ : mLambda(std::move(aLambda))
{}
void operator()(JS::TrackedStrategy aStrategy, JS::TrackedOutcome aOutcome) override {
mLambda(aStrategy, aOutcome);
}
private:
LambdaT mLambda;
};
template<typename LambdaT> ForEachTrackedOptimizationAttemptsLambdaOp<LambdaT>
MakeForEachTrackedOptimizationAttemptsLambdaOp(LambdaT&& aLambda)
{
- return ForEachTrackedOptimizationAttemptsLambdaOp<LambdaT>(Move(aLambda));
+ return ForEachTrackedOptimizationAttemptsLambdaOp<LambdaT>(std::move(aLambda));
}
UniqueJSONStrings::UniqueJSONStrings()
{
mStringTableWriter.StartBareList();
}
UniqueJSONStrings::UniqueJSONStrings(const UniqueJSONStrings& aOther)
@@ -322,17 +322,17 @@ JITFrameInfoForBufferRange
JITFrameInfoForBufferRange::Clone() const
{
nsClassHashtable<nsPtrHashKey<void>, nsTArray<JITFrameKey>> jitAddressToJITFramesMap;
nsClassHashtable<nsGenericHashKey<JITFrameKey>, nsCString> jitFrameToFrameJSONMap;
CopyClassHashtable(jitAddressToJITFramesMap, mJITAddressToJITFramesMap);
CopyClassHashtable(jitFrameToFrameJSONMap, mJITFrameToFrameJSONMap);
return JITFrameInfoForBufferRange{
mRangeStart, mRangeEnd,
- Move(jitAddressToJITFramesMap), Move(jitFrameToFrameJSONMap) };
+ std::move(jitAddressToJITFramesMap), std::move(jitFrameToFrameJSONMap) };
}
JITFrameInfo::JITFrameInfo(const JITFrameInfo& aOther)
: mUniqueStrings(MakeUnique<UniqueJSONStrings>(*aOther.mUniqueStrings))
{
for (const JITFrameInfoForBufferRange& range : aOther.mRanges) {
mRanges.AppendElement(range.Clone());
}
@@ -378,18 +378,18 @@ UniqueStacks::FrameKey::Hash() const
return hash;
}
// Consume aJITFrameInfo by stealing its string table and its JIT frame info
// ranges. The JIT frame info contains JSON which refers to strings from the
// JIT frame info's string table, so our string table needs to have the same
// strings at the same indices.
UniqueStacks::UniqueStacks(JITFrameInfo&& aJITFrameInfo)
- : mUniqueStrings(Move(aJITFrameInfo.mUniqueStrings))
- , mJITInfoRanges(Move(aJITFrameInfo.mRanges))
+ : mUniqueStrings(std::move(aJITFrameInfo.mUniqueStrings))
+ , mJITInfoRanges(std::move(aJITFrameInfo.mRanges))
{
mFrameTableWriter.StartBareList();
mStackTableWriter.StartBareList();
}
uint32_t UniqueStacks::GetOrAddStackIndex(const StackKey& aStack)
{
uint32_t index;
@@ -447,19 +447,19 @@ UniqueStacks::LookupFramesForJITAddressF
// the frame table and give it an index.
uint32_t index = mFrameToIndexMap.Count();
const nsCString* frameJSON =
jitFrameInfoRange.mJITFrameToFrameJSONMap.Get(jitFrameKey);
MOZ_RELEASE_ASSERT(frameJSON, "Should have cached JSON for this frame");
mFrameTableWriter.Splice(frameJSON->get());
mFrameToIndexMap.Put(frameKey, index);
}
- frameKeys.AppendElement(Move(frameKey));
+ frameKeys.AppendElement(std::move(frameKey));
}
- return Some(Move(frameKeys));
+ return Some(std::move(frameKeys));
}
uint32_t
UniqueStacks::GetOrAddFrameIndex(const FrameKey& aFrame)
{
uint32_t index;
if (mFrameToIndexMap.Get(aFrame, &index)) {
MOZ_ASSERT(index < mFrameToIndexMap.Count());
@@ -707,17 +707,17 @@ JITFrameInfo::AddInfoForRange(uint64_t a
}
jitFrameKeys.AppendElement(jitFrameKey);
}
}
});
mRanges.AppendElement(JITFrameInfoForBufferRange{
aRangeStart, aRangeEnd,
- Move(jitAddressToJITFrameMap), Move(jitFrameToFrameJSONMap)
+ std::move(jitAddressToJITFrameMap), std::move(jitFrameToFrameJSONMap)
});
}
struct ProfileSample
{
uint32_t mStack;
double mTime;
Maybe<double> mResponsiveness;
--- a/tools/profiler/core/ProfileJSONWriter.cpp
+++ b/tools/profiler/core/ProfileJSONWriter.cpp
@@ -57,17 +57,17 @@ ChunkedJSONWriteFunc::CopyData() const
return c;
}
void
ChunkedJSONWriteFunc::Take(ChunkedJSONWriteFunc&& aOther)
{
for (size_t i = 0; i < aOther.mChunkList.length(); i++) {
MOZ_ALWAYS_TRUE(mChunkLengths.append(aOther.mChunkLengths[i]));
- MOZ_ALWAYS_TRUE(mChunkList.append(mozilla::Move(aOther.mChunkList[i])));
+ MOZ_ALWAYS_TRUE(mChunkList.append(std::move(aOther.mChunkList[i])));
}
mChunkPtr = mChunkList.back().get() + mChunkLengths.back();
mChunkEnd = mChunkPtr;
aOther.mChunkPtr = nullptr;
aOther.mChunkEnd = nullptr;
aOther.mChunkList.clear();
aOther.mChunkLengths.clear();
}
@@ -76,17 +76,17 @@ void
ChunkedJSONWriteFunc::AllocChunk(size_t aChunkSize)
{
MOZ_ASSERT(mChunkLengths.length() == mChunkList.length());
mozilla::UniquePtr<char[]> newChunk = mozilla::MakeUnique<char[]>(aChunkSize);
mChunkPtr = newChunk.get();
mChunkEnd = mChunkPtr + aChunkSize;
*mChunkPtr = '\0';
MOZ_ALWAYS_TRUE(mChunkLengths.append(0));
- MOZ_ALWAYS_TRUE(mChunkList.append(mozilla::Move(newChunk)));
+ MOZ_ALWAYS_TRUE(mChunkList.append(std::move(newChunk)));
}
void
SpliceableJSONWriter::TakeAndSplice(ChunkedJSONWriteFunc* aFunc)
{
Separator();
for (size_t i = 0; i < aFunc->mChunkList.length(); i++) {
WriteFunc()->Write(aFunc->mChunkList[i].get());
@@ -105,11 +105,11 @@ SpliceableJSONWriter::Splice(const char*
WriteFunc()->Write(aStr);
mNeedComma[mDepth] = true;
}
void
SpliceableChunkedJSONWriter::TakeAndSplice(ChunkedJSONWriteFunc* aFunc)
{
Separator();
- WriteFunc()->Take(mozilla::Move(*aFunc));
+ WriteFunc()->Take(std::move(*aFunc));
mNeedComma[mDepth] = true;
}
--- a/tools/profiler/core/ProfileJSONWriter.h
+++ b/tools/profiler/core/ProfileJSONWriter.h
@@ -77,17 +77,17 @@ struct OStreamJSONWriteFunc : public moz
std::ostream& mStream;
};
class SpliceableJSONWriter : public mozilla::JSONWriter
{
public:
explicit SpliceableJSONWriter(mozilla::UniquePtr<mozilla::JSONWriteFunc> aWriter)
- : JSONWriter(mozilla::Move(aWriter))
+ : JSONWriter(std::move(aWriter))
{ }
void StartBareList(CollectionStyle aStyle = MultiLineStyle) {
StartCollection(nullptr, "", aStyle);
}
void EndBareList() {
EndCollection("");
--- a/tools/profiler/core/ProfiledThreadData.cpp
+++ b/tools/profiler/core/ProfiledThreadData.cpp
@@ -48,17 +48,17 @@ ProfiledThreadData::StreamJSON(const Pro
JITFrameInfo jitFrameInfo = mJITFrameInfoForPreviousJSContexts
? JITFrameInfo(*mJITFrameInfoForPreviousJSContexts) : JITFrameInfo();
if (aCx && mBufferPositionWhenReceivedJSContext) {
aBuffer.AddJITInfoForRange(*mBufferPositionWhenReceivedJSContext,
mThreadInfo->ThreadId(), aCx, jitFrameInfo);
}
- UniqueStacks uniqueStacks(Move(jitFrameInfo));
+ UniqueStacks uniqueStacks(std::move(jitFrameInfo));
aWriter.Start();
{
StreamSamplesAndMarkers(mThreadInfo->Name(), mThreadInfo->ThreadId(),
aBuffer, aWriter,
aProcessStartTime,
mThreadInfo->RegisterTime(), mUnregisterTime,
aSinceTime, uniqueStacks);
@@ -191,16 +191,16 @@ ProfiledThreadData::NotifyAboutToLoseJSC
MOZ_RELEASE_ASSERT(aContext);
if (mJITFrameInfoForPreviousJSContexts &&
mJITFrameInfoForPreviousJSContexts->HasExpired(aBuffer.mRangeStart)) {
mJITFrameInfoForPreviousJSContexts = nullptr;
}
UniquePtr<JITFrameInfo> jitFrameInfo = mJITFrameInfoForPreviousJSContexts
- ? Move(mJITFrameInfoForPreviousJSContexts) : MakeUnique<JITFrameInfo>();
+ ? std::move(mJITFrameInfoForPreviousJSContexts) : MakeUnique<JITFrameInfo>();
aBuffer.AddJITInfoForRange(*mBufferPositionWhenReceivedJSContext,
mThreadInfo->ThreadId(), aContext, *jitFrameInfo);
- mJITFrameInfoForPreviousJSContexts = Move(jitFrameInfo);
+ mJITFrameInfoForPreviousJSContexts = std::move(jitFrameInfo);
mBufferPositionWhenReceivedJSContext = Nothing();
}
--- a/tools/profiler/core/ProfilerBacktrace.cpp
+++ b/tools/profiler/core/ProfilerBacktrace.cpp
@@ -8,17 +8,17 @@
#include "ProfileJSONWriter.h"
#include "ThreadInfo.h"
ProfilerBacktrace::ProfilerBacktrace(const char* aName, int aThreadId,
UniquePtr<ProfileBuffer> aBuffer)
: mName(strdup(aName))
, mThreadId(aThreadId)
- , mBuffer(Move(aBuffer))
+ , mBuffer(std::move(aBuffer))
{
MOZ_COUNT_CTOR(ProfilerBacktrace);
}
ProfilerBacktrace::~ProfilerBacktrace()
{
MOZ_COUNT_DTOR(ProfilerBacktrace);
}
--- a/tools/profiler/core/ProfilerMarker.h
+++ b/tools/profiler/core/ProfilerMarker.h
@@ -22,17 +22,17 @@ class ProfilerMarker
public:
explicit ProfilerMarker(const char* aMarkerName,
int aThreadId,
mozilla::UniquePtr<ProfilerMarkerPayload>
aPayload = nullptr,
double aTime = 0)
: mMarkerName(strdup(aMarkerName))
- , mPayload(Move(aPayload))
+ , mPayload(std::move(aPayload))
, mNext{nullptr}
, mTime(aTime)
, mPositionInBuffer{0}
, mThreadId{aThreadId}
{}
void SetPositionInBuffer(uint64_t aPosition) { mPositionInBuffer = aPosition; }
--- a/tools/profiler/core/RegisteredThread.h
+++ b/tools/profiler/core/RegisteredThread.h
@@ -32,17 +32,17 @@ public:
MOZ_COUNT_DTOR(RacyRegisteredThread);
}
void AddPendingMarker(const char* aMarkerName,
mozilla::UniquePtr<ProfilerMarkerPayload> aPayload,
double aTime)
{
ProfilerMarker* marker =
- new ProfilerMarker(aMarkerName, mThreadId, Move(aPayload), aTime);
+ new ProfilerMarker(aMarkerName, mThreadId, std::move(aPayload), aTime);
mPendingMarkers.insert(marker);
}
// Called within signal. Function must be reentrant.
ProfilerMarkerLinkedList* GetPendingMarkers()
{
// The profiled thread is interrupted, so we can access the list safely.
// Unless the profiled thread was in the middle of changing the list when
--- a/tools/profiler/core/platform.cpp
+++ b/tools/profiler/core/platform.cpp
@@ -264,33 +264,33 @@ public:
// No PSLockRef is needed for this field because it's immutable.
PS_GET_LOCKLESS(TimeStamp, ProcessStartTime)
PS_GET(const nsTArray<UniquePtr<RegisteredThread>>&, RegisteredThreads)
static void AppendRegisteredThread(PSLockRef, UniquePtr<RegisteredThread>&& aRegisteredThread)
{
- sInstance->mRegisteredThreads.AppendElement(Move(aRegisteredThread));
+ sInstance->mRegisteredThreads.AppendElement(std::move(aRegisteredThread));
}
static void RemoveRegisteredThread(PSLockRef, RegisteredThread* aRegisteredThread)
{
// Remove aRegisteredThread from mRegisteredThreads.
// Can't use RemoveElement() because we can't equality-compare a UniquePtr
// to a raw pointer.
sInstance->mRegisteredThreads.RemoveElementsBy(
[&](UniquePtr<RegisteredThread>& rt) { return rt.get() == aRegisteredThread; });
}
#ifdef USE_LUL_STACKWALK
static lul::LUL* Lul(PSLockRef) { return sInstance->mLul.get(); }
static void SetLul(PSLockRef, UniquePtr<lul::LUL> aLul)
{
- sInstance->mLul = Move(aLul);
+ sInstance->mLul = std::move(aLul);
}
#endif
private:
// The singleton instance
static CorePS* sInstance;
// The time that the process started.
@@ -571,17 +571,17 @@ public:
return nullptr;
}
static ProfiledThreadData*
AddLiveProfiledThread(PSLockRef, RegisteredThread* aRegisteredThread,
UniquePtr<ProfiledThreadData>&& aProfiledThreadData)
{
sInstance->mLiveProfiledThreads.AppendElement(
- LiveProfiledThreadData{ aRegisteredThread, Move(aProfiledThreadData) });
+ LiveProfiledThreadData{ aRegisteredThread, std::move(aProfiledThreadData) });
// Return a weak pointer to the ProfiledThreadData object.
return sInstance->mLiveProfiledThreads.LastElement().mProfiledThreadData.get();
}
static void UnregisterThread(PSLockRef aLockRef, RegisteredThread* aRegisteredThread)
{
DiscardExpiredDeadProfiledThreads(aLockRef);
@@ -589,17 +589,17 @@ public:
// Find the right entry in the mLiveProfiledThreads array and remove the
// element, moving the ProfiledThreadData object for the thread into the
// mDeadProfiledThreads array.
// The thread's RegisteredThread object gets destroyed here.
for (size_t i = 0; i < sInstance->mLiveProfiledThreads.Length(); i++) {
LiveProfiledThreadData& thread = sInstance->mLiveProfiledThreads[i];
if (thread.mRegisteredThread == aRegisteredThread) {
thread.mProfiledThreadData->NotifyUnregistered(sInstance->mBuffer->mRangeEnd);
- sInstance->mDeadProfiledThreads.AppendElement(Move(thread.mProfiledThreadData));
+ sInstance->mDeadProfiledThreads.AppendElement(std::move(thread.mProfiledThreadData));
sInstance->mLiveProfiledThreads.RemoveElementAt(i);
return;
}
}
}
PS_GET_AND_SET(bool, IsPaused)
@@ -1727,17 +1727,17 @@ CollectJavaThreadProfileData()
if (!frameName) {
break;
}
buffer->CollectCodeLocation("", frameName->ToCString().get(), -1,
Nothing());
}
sampleId++;
}
- return Move(buffer);
+ return std::move(buffer);
}
#endif
static void
locked_profiler_stream_json_for_this_process(PSLockRef aLock,
SpliceableJSONWriter& aWriter,
double aSinceTime,
bool aIsShuttingDown)
@@ -2283,17 +2283,17 @@ locked_register_thread(PSLockRef aLock,
ActivePS::FeatureTrackOptimizations(aLock));
registeredThread->PollJSSampling();
if (registeredThread->GetJSContext()) {
profiledThreadData->NotifyReceivedJSContext(ActivePS::Buffer(aLock).mRangeEnd);
}
}
}
- CorePS::AppendRegisteredThread(aLock, Move(registeredThread));
+ CorePS::AppendRegisteredThread(aLock, std::move(registeredThread));
}
static void
NotifyObservers(const char* aTopic, nsISupports* aSubject = nullptr)
{
if (!NS_IsMainThread()) {
// Dispatch a task to the main thread that notifies observers.
// If NotifyObservers is called both on and off the main thread within a
@@ -3311,17 +3311,17 @@ profiler_get_backtrace()
#endif
// 1000 should be plenty for a single backtrace.
auto buffer = MakeUnique<ProfileBuffer>(1000);
DoSyncSample(lock, *registeredThread, now, regs, *buffer.get());
return UniqueProfilerBacktrace(
- new ProfilerBacktrace("SyncProfile", tid, Move(buffer)));
+ new ProfilerBacktrace("SyncProfile", tid, std::move(buffer)));
}
void
ProfilerBacktraceDestructor::operator()(ProfilerBacktrace* aBacktrace)
{
delete aBacktrace;
}
@@ -3343,32 +3343,32 @@ racy_profiler_add_marker(const char* aMa
if (!racyRegisteredThread) {
return;
}
TimeStamp origin = (aPayload && !aPayload->GetStartTime().IsNull())
? aPayload->GetStartTime()
: TimeStamp::Now();
TimeDuration delta = origin - CorePS::ProcessStartTime();
- racyRegisteredThread->AddPendingMarker(aMarkerName, Move(aPayload),
+ racyRegisteredThread->AddPendingMarker(aMarkerName, std::move(aPayload),
delta.ToMilliseconds());
}
void
profiler_add_marker(const char* aMarkerName,
UniquePtr<ProfilerMarkerPayload> aPayload)
{
MOZ_RELEASE_ASSERT(CorePS::Exists());
// This function is hot enough that we use RacyFeatures, not ActivePS.
if (!RacyFeatures::IsActiveWithoutPrivacy()) {
return;
}
- racy_profiler_add_marker(aMarkerName, Move(aPayload));
+ racy_profiler_add_marker(aMarkerName, std::move(aPayload));
}
void
profiler_add_marker(const char* aMarkerName)
{
profiler_add_marker(aMarkerName, nullptr);
}
@@ -3426,17 +3426,17 @@ profiler_add_marker_for_thread(int aThre
}
// Create the ProfilerMarker which we're going to store.
TimeStamp origin = (aPayload && !aPayload->GetStartTime().IsNull())
? aPayload->GetStartTime()
: TimeStamp::Now();
TimeDuration delta = origin - CorePS::ProcessStartTime();
ProfilerMarker* marker =
- new ProfilerMarker(aMarkerName, aThreadId, Move(aPayload),
+ new ProfilerMarker(aMarkerName, aThreadId, std::move(aPayload),
delta.ToMilliseconds());
#ifdef DEBUG
// Assert that our thread ID makes sense
bool realThread = false;
const nsTArray<UniquePtr<RegisteredThread>>& registeredThreads =
CorePS::RegisteredThreads(lock);
for (auto& thread : registeredThreads) {
@@ -3464,35 +3464,35 @@ profiler_tracing(const char* aCategory,
VTUNE_TRACING(aMarkerName, aKind);
// This function is hot enough that we use RacyFeatures, notActivePS.
if (!RacyFeatures::IsActiveWithoutPrivacy()) {
return;
}
auto payload = MakeUnique<TracingMarkerPayload>(aCategory, aKind);
- racy_profiler_add_marker(aMarkerName, Move(payload));
+ racy_profiler_add_marker(aMarkerName, std::move(payload));
}
void
profiler_tracing(const char* aCategory, const char* aMarkerName,
TracingKind aKind, UniqueProfilerBacktrace aCause)
{
MOZ_RELEASE_ASSERT(CorePS::Exists());
VTUNE_TRACING(aMarkerName, aKind);
// This function is hot enough that we use RacyFeatures, notActivePS.
if (!RacyFeatures::IsActiveWithoutPrivacy()) {
return;
}
auto payload =
- MakeUnique<TracingMarkerPayload>(aCategory, aKind, Move(aCause));
- racy_profiler_add_marker(aMarkerName, Move(payload));
+ MakeUnique<TracingMarkerPayload>(aCategory, aKind, std::move(aCause));
+ racy_profiler_add_marker(aMarkerName, std::move(payload));
}
void
profiler_set_js_context(JSContext* aCx)
{
MOZ_ASSERT(aCx);
PSAutoLock lock(gPSMutex);
--- a/tools/profiler/gecko/ChildProfilerController.cpp
+++ b/tools/profiler/gecko/ChildProfilerController.cpp
@@ -12,17 +12,17 @@ using namespace mozilla::ipc;
namespace mozilla {
/* static */ already_AddRefed<ChildProfilerController>
ChildProfilerController::Create(mozilla::ipc::Endpoint<PProfilerChild>&& aEndpoint)
{
MOZ_RELEASE_ASSERT(NS_IsMainThread());
RefPtr<ChildProfilerController> cpc = new ChildProfilerController();
- cpc->Init(Move(aEndpoint));
+ cpc->Init(std::move(aEndpoint));
return cpc.forget();
}
ChildProfilerController::ChildProfilerController()
{
MOZ_COUNT_CTOR(ChildProfilerController);
}
@@ -30,17 +30,17 @@ void
ChildProfilerController::Init(Endpoint<PProfilerChild>&& aEndpoint)
{
if (NS_SUCCEEDED(NS_NewNamedThread("ProfilerChild", getter_AddRefs(mThread)))) {
// Now that mThread has been set, run SetupProfilerChild on the thread.
mThread->Dispatch(NewRunnableMethod<Endpoint<PProfilerChild>&&>(
"ChildProfilerController::SetupProfilerChild",
this,
&ChildProfilerController::SetupProfilerChild,
- Move(aEndpoint)),
+ std::move(aEndpoint)),
NS_DISPATCH_NORMAL);
}
}
nsCString
ChildProfilerController::GrabShutdownProfileAndShutdown()
{
nsCString shutdownProfile;
@@ -81,17 +81,17 @@ ChildProfilerController::~ChildProfilerC
void
ChildProfilerController::SetupProfilerChild(Endpoint<PProfilerChild>&& aEndpoint)
{
MOZ_RELEASE_ASSERT(mThread == NS_GetCurrentThread());
MOZ_ASSERT(aEndpoint.IsValid());
mProfilerChild = new ProfilerChild();
- Endpoint<PProfilerChild> endpoint = Move(aEndpoint);
+ Endpoint<PProfilerChild> endpoint = std::move(aEndpoint);
if (!endpoint.Bind(mProfilerChild)) {
MOZ_CRASH("Failed to bind ProfilerChild!");
}
}
void
ChildProfilerController::ShutdownProfilerChild(nsCString* aOutShutdownProfile)
--- a/tools/profiler/gecko/ProfilerIOInterposeObserver.cpp
+++ b/tools/profiler/gecko/ProfilerIOInterposeObserver.cpp
@@ -18,10 +18,10 @@ void ProfilerIOInterposeObserver::Observ
nsString filename;
aObservation.Filename(filename);
profiler_add_marker(
aObservation.ObservedOperationString(),
MakeUnique<IOMarkerPayload>(aObservation.Reference(),
NS_ConvertUTF16toUTF8(filename).get(),
aObservation.Start(), aObservation.End(),
- Move(stack)));
+ std::move(stack)));
}
--- a/tools/profiler/lul/LulMain.cpp
+++ b/tools/profiler/lul/LulMain.cpp
@@ -577,20 +577,20 @@ class PriMap {
if (aSecMap->mSummaryMinAddr < sm_i->mSummaryMaxAddr) {
// |aSecMap| needs to be inserted immediately before mSecMaps[i].
break;
}
}
MOZ_ASSERT(i <= num_secMaps);
if (i == num_secMaps) {
// It goes at the end.
- mSecMaps.push_back(mozilla::Move(aSecMap));
+ mSecMaps.push_back(std::move(aSecMap));
} else {
std::vector<mozilla::UniquePtr<SecMap>>::iterator iter = mSecMaps.begin() + i;
- mSecMaps.insert(iter, mozilla::Move(aSecMap));
+ mSecMaps.insert(iter, std::move(aSecMap));
}
char buf[100];
SprintfLiteral(buf, "AddSecMap: now have %d SecMaps\n",
(int)mSecMaps.size());
buf[sizeof(buf)-1] = 0;
mLog(buf);
}
@@ -799,17 +799,17 @@ LUL::NotifyAfterMap(uintptr_t aRXavma, s
smap->PrepareRuleSets(aRXavma, aSize);
SprintfLiteral(buf,
"NotifyMap got %lld entries\n", (long long int)smap->Size());
buf[sizeof(buf)-1] = 0;
mLog(buf);
// Add it to the primary map (the top level set of mapped objects).
- mPriMap->AddSecMap(mozilla::Move(smap));
+ mPriMap->AddSecMap(std::move(smap));
// Tell the segment array about the mapping, so that the stack
// scan and __kernel_syscall mechanisms know where valid code is.
mSegArray->add(aRXavma, aRXavma + aSize - 1, true);
}
}
--- a/tools/profiler/public/GeckoProfiler.h
+++ b/tools/profiler/public/GeckoProfiler.h
@@ -772,17 +772,17 @@ public:
AutoProfilerTracing(const char* aCategory, const char* aMarkerName,
UniqueProfilerBacktrace aBacktrace
MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
: mCategory(aCategory)
, mMarkerName(aMarkerName)
{
MOZ_GUARD_OBJECT_NOTIFIER_INIT;
profiler_tracing(mCategory, mMarkerName, TRACING_INTERVAL_START,
- Move(aBacktrace));
+ std::move(aBacktrace));
}
~AutoProfilerTracing()
{
profiler_tracing(mCategory, mMarkerName, TRACING_INTERVAL_END);
}
protected:
--- a/tools/profiler/public/ProfilerMarkerPayload.h
+++ b/tools/profiler/public/ProfilerMarkerPayload.h
@@ -34,25 +34,25 @@ class UniqueStacks;
// attached with a profiler marker.
//
// When subclassing this, note that the destructor can be called on any thread,
// i.e. not necessarily on the thread that created the object.
class ProfilerMarkerPayload
{
public:
explicit ProfilerMarkerPayload(UniqueProfilerBacktrace aStack = nullptr)
- : mStack(Move(aStack))
+ : mStack(std::move(aStack))
{}
ProfilerMarkerPayload(const mozilla::TimeStamp& aStartTime,
const mozilla::TimeStamp& aEndTime,
UniqueProfilerBacktrace aStack = nullptr)
: mStartTime(aStartTime)
, mEndTime(aEndTime)
- , mStack(Move(aStack))
+ , mStack(std::move(aStack))
{}
virtual ~ProfilerMarkerPayload() {}
virtual void StreamPayload(SpliceableJSONWriter& aWriter,
const mozilla::TimeStamp& aProcessStartTime,
UniqueStacks& aUniqueStacks) = 0;
@@ -61,17 +61,17 @@ public:
protected:
void StreamCommonProps(const char* aMarkerType,
SpliceableJSONWriter& aWriter,
const mozilla::TimeStamp& aProcessStartTime,
UniqueStacks& aUniqueStacks);
void SetStack(UniqueProfilerBacktrace aStack)
{
- mStack = mozilla::Move(aStack);
+ mStack = std::move(aStack);
}
private:
mozilla::TimeStamp mStartTime;
mozilla::TimeStamp mEndTime;
UniqueProfilerBacktrace mStack;
};
@@ -84,17 +84,17 @@ class TracingMarkerPayload : public Prof
{
public:
TracingMarkerPayload(const char* aCategory, TracingKind aKind,
UniqueProfilerBacktrace aCause = nullptr)
: mCategory(aCategory)
, mKind(aKind)
{
if (aCause) {
- SetStack(Move(aCause));
+ SetStack(std::move(aCause));
}
}
DECL_STREAM_PAYLOAD
private:
const char *mCategory;
TracingKind mKind;
@@ -102,17 +102,17 @@ private:
class IOMarkerPayload : public ProfilerMarkerPayload
{
public:
IOMarkerPayload(const char* aSource, const char* aFilename,
const mozilla::TimeStamp& aStartTime,
const mozilla::TimeStamp& aEndTime,
UniqueProfilerBacktrace aStack)
- : ProfilerMarkerPayload(aStartTime, aEndTime, Move(aStack))
+ : ProfilerMarkerPayload(aStartTime, aEndTime, std::move(aStack))
, mSource(aSource)
, mFilename(aFilename ? strdup(aFilename) : nullptr)
{
MOZ_ASSERT(aSource);
}
DECL_STREAM_PAYLOAD
@@ -249,17 +249,17 @@ private:
class ScreenshotPayload : public ProfilerMarkerPayload
{
public:
explicit ScreenshotPayload(mozilla::TimeStamp aTimeStamp,
nsCString&& aScreenshotDataURL,
const mozilla::gfx::IntSize& aWindowSize,
uintptr_t aWindowIdentifier)
: ProfilerMarkerPayload(aTimeStamp, mozilla::TimeStamp())
- , mScreenshotDataURL(mozilla::Move(aScreenshotDataURL))
+ , mScreenshotDataURL(std::move(aScreenshotDataURL))
, mWindowSize(aWindowSize)
, mWindowIdentifier(aWindowIdentifier)
{}
DECL_STREAM_PAYLOAD
private:
nsCString mScreenshotDataURL;
@@ -269,49 +269,49 @@ private:
class GCSliceMarkerPayload : public ProfilerMarkerPayload
{
public:
GCSliceMarkerPayload(const mozilla::TimeStamp& aStartTime,
const mozilla::TimeStamp& aEndTime,
JS::UniqueChars&& aTimingJSON)
: ProfilerMarkerPayload(aStartTime, aEndTime),
- mTimingJSON(mozilla::Move(aTimingJSON))
+ mTimingJSON(std::move(aTimingJSON))
{}
DECL_STREAM_PAYLOAD
private:
JS::UniqueChars mTimingJSON;
};
class GCMajorMarkerPayload : public ProfilerMarkerPayload
{
public:
GCMajorMarkerPayload(const mozilla::TimeStamp& aStartTime,
const mozilla::TimeStamp& aEndTime,
JS::UniqueChars&& aTimingJSON)
: ProfilerMarkerPayload(aStartTime, aEndTime),
- mTimingJSON(mozilla::Move(aTimingJSON))
+ mTimingJSON(std::move(aTimingJSON))
{}
DECL_STREAM_PAYLOAD
private:
JS::UniqueChars mTimingJSON;
};
class GCMinorMarkerPayload : public ProfilerMarkerPayload
{
public:
GCMinorMarkerPayload(const mozilla::TimeStamp& aStartTime,
const mozilla::TimeStamp& aEndTime,
JS::UniqueChars&& aTimingData)
: ProfilerMarkerPayload(aStartTime, aEndTime),
- mTimingData(mozilla::Move(aTimingData))
+ mTimingData(std::move(aTimingData))
{}
DECL_STREAM_PAYLOAD
private:
JS::UniqueChars mTimingData;
};
@@ -333,17 +333,17 @@ public:
StyleMarkerPayload(const mozilla::TimeStamp& aStartTime,
const mozilla::TimeStamp& aEndTime,
UniqueProfilerBacktrace aCause,
const mozilla::ServoTraversalStatistics& aStats)
: ProfilerMarkerPayload(aStartTime, aEndTime)
, mStats(aStats)
{
if (aCause) {
- SetStack(Move(aCause));
+ SetStack(std::move(aCause));
}
}
DECL_STREAM_PAYLOAD
private:
mozilla::ServoTraversalStatistics mStats;
};
--- a/tools/profiler/tasktracer/TracedTaskCommon.cpp
+++ b/tools/profiler/tasktracer/TracedTaskCommon.cpp
@@ -95,17 +95,17 @@ TracedTaskCommon::ClearTLSTraceInfo()
/**
* Implementation of class TracedRunnable.
*/
NS_IMPL_ISUPPORTS(TracedRunnable, nsIRunnable);
TracedRunnable::TracedRunnable(already_AddRefed<nsIRunnable>&& aOriginalObj)
: TracedTaskCommon()
- , mOriginalObj(Move(aOriginalObj))
+ , mOriginalObj(std::move(aOriginalObj))
{
Init();
LogVirtualTablePtr(mTaskId, mSourceEventId, *reinterpret_cast<uintptr_t**>(mOriginalObj.get()));
}
TracedRunnable::~TracedRunnable()
{
}
@@ -124,17 +124,17 @@ TracedRunnable::Run()
/**
* CreateTracedRunnable() returns a TracedRunnable wrapping the original
* nsIRunnable object, aRunnable.
*/
already_AddRefed<nsIRunnable>
CreateTracedRunnable(already_AddRefed<nsIRunnable>&& aRunnable)
{
- RefPtr<nsIRunnable> runnable = new TracedRunnable(Move(aRunnable));
+ RefPtr<nsIRunnable> runnable = new TracedRunnable(std::move(aRunnable));
return runnable.forget();
}
void
VirtualTask::AutoRunTask::StartScope(VirtualTask* aTask)
{
mTask->SetTLSTraceInfo();
LogBegin(mTask->mTaskId, mTask->mSourceEventId);
--- a/tools/profiler/tests/gtest/GeckoProfiler.cpp
+++ b/tools/profiler/tests/gtest/GeckoProfiler.cpp
@@ -441,17 +441,17 @@ TEST(GeckoProfiler, Markers)
profiler_start(PROFILER_DEFAULT_ENTRIES, PROFILER_DEFAULT_INTERVAL,
features, filters, MOZ_ARRAY_LENGTH(filters));
profiler_tracing("A", "B", TRACING_EVENT);
PROFILER_TRACING("A", "C", TRACING_INTERVAL_START);
PROFILER_TRACING("A", "C", TRACING_INTERVAL_END);
UniqueProfilerBacktrace bt = profiler_get_backtrace();
- profiler_tracing("B", "A", TRACING_EVENT, Move(bt));
+ profiler_tracing("B", "A", TRACING_EVENT, std::move(bt));
{
AUTO_PROFILER_TRACING("C", "A");
}
profiler_add_marker("M1");
profiler_add_marker(
"M2", MakeUnique<TracingMarkerPayload>("C", TRACING_EVENT));
--- a/uriloader/exthandler/ContentHandlerService.cpp
+++ b/uriloader/exthandler/ContentHandlerService.cpp
@@ -70,29 +70,29 @@ ContentHandlerService::nsIHandlerInfoToH
if (isMIMEInfo) {
nsCOMPtr<nsIUTF8StringEnumerator> extensionsIter;
mimeInfo->GetFileExtensions(getter_AddRefs(extensionsIter));
if (extensionsIter) {
bool hasMore = false;
while (NS_SUCCEEDED(extensionsIter->HasMore(&hasMore)) && hasMore) {
nsAutoCString extension;
if (NS_SUCCEEDED(extensionsIter->GetNext(extension))) {
- extensions.AppendElement(Move(extension));
+ extensions.AppendElement(std::move(extension));
}
}
}
}
nsHandlerInfoAction action;
aInfo->GetPreferredAction(&action);
HandlerInfo info(type,
isMIMEInfo,
description,
alwaysAskBeforeHandling,
- Move(extensions),
+ std::move(extensions),
happ,
happs,
action);
*aHandlerInfo = info;
}
NS_IMETHODIMP RemoteHandlerApp::GetName(nsAString & aName)
--- a/widget/BasicEvents.h
+++ b/widget/BasicEvents.h
@@ -548,31 +548,31 @@ public:
: WidgetEventTime()
{
MOZ_COUNT_CTOR(WidgetEvent);
*this = aOther;
}
WidgetEvent& operator=(const WidgetEvent& aOther) = default;
WidgetEvent(WidgetEvent&& aOther)
- : WidgetEventTime(Move(aOther))
+ : WidgetEventTime(std::move(aOther))
, mClass(aOther.mClass)
, mMessage(aOther.mMessage)
- , mRefPoint(Move(aOther.mRefPoint))
- , mLastRefPoint(Move(aOther.mLastRefPoint))
+ , mRefPoint(std::move(aOther.mRefPoint))
+ , mLastRefPoint(std::move(aOther.mLastRefPoint))
, mFocusSequenceNumber(aOther.mFocusSequenceNumber)
- , mFlags(Move(aOther.mFlags))
- , mSpecifiedEventType(Move(aOther.mSpecifiedEventType))
- , mSpecifiedEventTypeString(Move(aOther.mSpecifiedEventTypeString))
- , mTarget(Move(aOther.mTarget))
- , mCurrentTarget(Move(aOther.mCurrentTarget))
- , mOriginalTarget(Move(aOther.mOriginalTarget))
- , mRelatedTarget(Move(aOther.mRelatedTarget))
- , mOriginalRelatedTarget(Move(aOther.mOriginalRelatedTarget))
- , mPath(Move(aOther.mPath))
+ , mFlags(std::move(aOther.mFlags))
+ , mSpecifiedEventType(std::move(aOther.mSpecifiedEventType))
+ , mSpecifiedEventTypeString(std::move(aOther.mSpecifiedEventTypeString))
+ , mTarget(std::move(aOther.mTarget))
+ , mCurrentTarget(std::move(aOther.mCurrentTarget))
+ , mOriginalTarget(std::move(aOther.mOriginalTarget))
+ , mRelatedTarget(std::move(aOther.mRelatedTarget))
+ , mOriginalRelatedTarget(std::move(aOther.mOriginalRelatedTarget))
+ , mPath(std::move(aOther.mPath))
{
MOZ_COUNT_CTOR(WidgetEvent);
}
WidgetEvent& operator=(WidgetEvent&& aOther) = default;
virtual WidgetEvent* Duplicate() const
{
MOZ_ASSERT(mClass == eBasicEventClass,
--- a/widget/ContentCache.cpp
+++ b/widget/ContentCache.cpp
@@ -311,17 +311,17 @@ ContentCacheInChild::QueryCharRectArray(
nsEventStatus status = nsEventStatus_eIgnore;
WidgetQueryContentEvent textRects(true, eQueryTextRectArray, aWidget);
textRects.InitForQueryTextRectArray(aOffset, aLength);
aWidget->DispatchEvent(&textRects, status);
if (NS_WARN_IF(!textRects.mSucceeded)) {
aCharRectArray.Clear();
return false;
}
- aCharRectArray = Move(textRects.mReply.mRectArray);
+ aCharRectArray = std::move(textRects.mReply.mRectArray);
return true;
}
bool
ContentCacheInChild::CacheTextRects(nsIWidget* aWidget,
const IMENotification* aNotification)
{
MOZ_LOG(sContentCacheLog, LogLevel::Info,
--- a/widget/PuppetWidget.h
+++ b/widget/PuppetWidget.h
@@ -92,17 +92,17 @@ public:
{ return mVisible; }
virtual void ConstrainPosition(bool /*ignored aAllowSlop*/,
int32_t* aX,
int32_t* aY) override
{ *aX = kMaxDimension; *aY = kMaxDimension; }
// Widget position is controlled by the parent process via TabChild.
- virtual void Move(double aX, double aY) override {}
+ virtual void std::move(double aX, double aY) override {}
virtual void Resize(double aWidth,
double aHeight,
bool aRepaint) override;
virtual void Resize(double aX,
double aY,
double aWidth,
double aHeight,
--- a/widget/ScreenManager.cpp
+++ b/widget/ScreenManager.cpp
@@ -44,25 +44,25 @@ ScreenManager::GetAddRefedSingleton()
{
RefPtr<ScreenManager> sm = &GetSingleton();
return sm.forget();
}
void
ScreenManager::SetHelper(UniquePtr<Helper> aHelper)
{
- mHelper = Move(aHelper);
+ mHelper = std::move(aHelper);
}
void
ScreenManager::Refresh(nsTArray<RefPtr<Screen>>&& aScreens)
{
MOZ_LOG(sScreenLog, LogLevel::Debug, ("Refresh screens"));
- mScreenList = Move(aScreens);
+ mScreenList = std::move(aScreens);
CopyScreensToAllRemotesIfIsParent();
}
void
ScreenManager::Refresh(nsTArray<mozilla::dom::ScreenDetails>&& aScreens)
{
MOZ_LOG(sScreenLog, LogLevel::Debug, ("Refresh screens from IPC"));
--- a/widget/android/AndroidUiThread.cpp
+++ b/widget/android/AndroidUiThread.cpp
@@ -67,27 +67,27 @@ private:
~AndroidUiThread()
{}
};
NS_IMETHODIMP
AndroidUiThread::Dispatch(already_AddRefed<nsIRunnable> aEvent, uint32_t aFlags)
{
if (aFlags & NS_DISPATCH_SYNC) {
- return nsThread::Dispatch(Move(aEvent), aFlags);
+ return nsThread::Dispatch(std::move(aEvent), aFlags);
} else {
- EnqueueTask(Move(aEvent), 0);
+ EnqueueTask(std::move(aEvent), 0);
return NS_OK;
}
}
NS_IMETHODIMP
AndroidUiThread::DelayedDispatch(already_AddRefed<nsIRunnable> aEvent, uint32_t aDelayMs)
{
- EnqueueTask(Move(aEvent), aDelayMs);
+ EnqueueTask(std::move(aEvent), aDelayMs);
return NS_OK;
}
static void
PumpEvents() {
NS_ProcessPendingEvents(sThread.get());
}
@@ -235,18 +235,18 @@ EnqueueTask(already_AddRefed<nsIRunnable
{
if (sThreadDestroyed) {
return;
}
// add the new task into the sTaskQueue, sorted with
// the earliest task first in the queue
- AndroidUiTask* newTask = (aDelayMs ? new AndroidUiTask(mozilla::Move(aTask), aDelayMs)
- : new AndroidUiTask(mozilla::Move(aTask)));
+ AndroidUiTask* newTask = (aDelayMs ? new AndroidUiTask(std::move(aTask), aDelayMs)
+ : new AndroidUiTask(std::move(aTask)));
bool headOfList = false;
{
MOZ_ASSERT(sTaskQueue);
MOZ_ASSERT(sTaskQueueLock);
MutexAutoLock lock(*sTaskQueueLock);
AndroidUiTask* task = sTaskQueue->getFirst();
--- a/widget/android/EventDispatcher.cpp
+++ b/widget/android/EventDispatcher.cpp
@@ -683,17 +683,17 @@ public:
template<typename Functor>
static void OnNativeCall(Functor&& aCall)
{
if (NS_IsMainThread()) {
// Invoke callbacks synchronously if we're already on Gecko thread.
return aCall();
}
- NS_DispatchToMainThread(NS_NewRunnableFunction("OnNativeCall", Move(aCall)));
+ NS_DispatchToMainThread(NS_NewRunnableFunction("OnNativeCall", std::move(aCall)));
}
static void Finalize(const CallbackDelegate::LocalRef& aInstance)
{
DisposeNative(aInstance);
}
NativeCallbackDelegateSupport(nsIAndroidEventCallback* callback,
--- a/widget/android/GeckoEditableSupport.h
+++ b/widget/android/GeckoEditableSupport.h
@@ -138,17 +138,17 @@ class GeckoEditableSupport final
void UpdateCompositionRects();
public:
template<typename Functor>
static void OnNativeCall(Functor&& aCall)
{
struct IMEEvent : nsAppShell::LambdaEvent<Functor>
{
- explicit IMEEvent(Functor&& l) : nsAppShell::LambdaEvent<Functor>(Move(l)) {}
+ explicit IMEEvent(Functor&& l) : nsAppShell::LambdaEvent<Functor>(std::move(l)) {}
nsAppShell::Event::Type ActivityType() const override
{
using GES = GeckoEditableSupport;
if (this->lambda.IsTarget(&GES::OnKeyEvent) ||
this->lambda.IsTarget(&GES::OnImeReplaceText) ||
this->lambda.IsTarget(&GES::OnImeUpdateComposition)) {
return nsAppShell::Event::Type::kUIActivity;
@@ -162,17 +162,17 @@ public:
// Ignore stale calls after disposal.
jni::GetGeckoThreadEnv()->ExceptionClear();
return;
}
nsAppShell::LambdaEvent<Functor>::Run();
}
};
nsAppShell::PostEvent(mozilla::MakeUnique<IMEEvent>(
- mozilla::Move(aCall)));
+ std::move(aCall)));
}
// Constructor for main process GeckoEditableChild.
GeckoEditableSupport(nsWindow::NativePtr<GeckoEditableSupport>* aPtr,
nsWindow* aWindow,
java::GeckoEditableChild::Param aEditableChild)
: mIsRemote(!aWindow)
, mWindow(aPtr, aWindow)
--- a/widget/android/PrefsHelper.h
+++ b/widget/android/PrefsHelper.h
@@ -136,17 +136,17 @@ public:
jni::Object::Param aPrefHandler)
{
nsTArray<jni::Object::LocalRef> nameRefArray(aPrefNames->GetElements());
nsCOMPtr<nsIObserverService> obsServ;
nsCOMPtr<nsIWritableVariant> value;
nsAutoString strVal;
for (jni::Object::LocalRef& nameRef : nameRefArray) {
- jni::String::LocalRef nameStr(mozilla::Move(nameRef));
+ jni::String::LocalRef nameStr(std::move(nameRef));
const nsCString& name = nameStr->ToCString();
int32_t type = java::PrefsHelper::PREF_INVALID;
bool boolVal = false;
int32_t intVal = 0;
strVal.Truncate();
switch (Preferences::GetType(name.get())) {
@@ -257,32 +257,32 @@ public:
}
nsTArray<jni::Object::LocalRef> nameRefArray(
aPrefsToObserve->GetElements());
nsAppShell* const appShell = nsAppShell::Get();
MOZ_ASSERT(appShell);
for (jni::Object::LocalRef& nameRef : nameRefArray) {
- jni::String::LocalRef nameStr(mozilla::Move(nameRef));
+ jni::String::LocalRef nameStr(std::move(nameRef));
MOZ_ALWAYS_SUCCEEDS(Preferences::AddStrongObserver(
appShell, nameStr->ToCString().get()));
}
}
static void RemoveObserver(const jni::Class::LocalRef& aCls,
jni::ObjectArray::Param aPrefsToUnobserve)
{
nsTArray<jni::Object::LocalRef> nameRefArray(
aPrefsToUnobserve->GetElements());
nsAppShell* const appShell = nsAppShell::Get();
MOZ_ASSERT(appShell);
for (jni::Object::LocalRef& nameRef : nameRefArray) {
- jni::String::LocalRef nameStr(mozilla::Move(nameRef));
+ jni::String::LocalRef nameStr(std::move(nameRef));
MOZ_ALWAYS_SUCCEEDS(Preferences::RemoveObserver(
appShell, nameStr->ToCString().get()));
}
}
static void OnPrefChange(const char16_t* aData)
{
const nsCString& name = NS_LossyConvertUTF16toASCII(aData);
--- a/widget/android/fennec/ThumbnailHelper.h
+++ b/widget/android/fennec/ThumbnailHelper.h
@@ -197,17 +197,17 @@ public:
class IdleEvent : public Runnable
{
Functor mLambda;
bool mIdlePass;
public:
explicit IdleEvent(Functor&& aCall)
: Runnable("ThumbnailHelperIdle")
- , mLambda(Move(aCall))
+ , mLambda(std::move(aCall))
, mIdlePass(false)
{}
NS_IMETHOD Run() override
{
// Because we can only post to the idle queue from the main
// queue, we must first post to the main queue and then to the
// idle queue. However, we use the same runnable object for
@@ -219,17 +219,17 @@ public:
mIdlePass = true;
MessageLoop::current()->PostIdleTask(
nsCOMPtr<nsIRunnable>(this).forget());
return NS_OK;
}
};
- NS_DispatchToMainThread(new IdleEvent(Move(aCall)));
+ NS_DispatchToMainThread(new IdleEvent(std::move(aCall)));
}
static void
RequestThumbnail(jni::ByteBuffer::Param aData, jni::Object::Param aTab,
int32_t aTabId, int32_t aWidth, int32_t aHeight)
{
nsCOMPtr<mozIDOMWindowProxy> window = GetWindowForTab(aTabId);
if (!window || !aData) {
--- a/widget/android/jni/Natives.h
+++ b/widget/android/jni/Natives.h
@@ -308,25 +308,25 @@ using namespace detail;
* {
* // ...
*
* template<class Functor>
* class ProxyRunnable final : public Runnable
* {
* Functor mCall;
* public:
- * ProxyRunnable(Functor&& call) : mCall(mozilla::Move(call)) {}
+ * ProxyRunnable(Functor&& call) : mCall(std::move(call)) {}
* virtual void run() override { mCall(); }
* };
*
* public:
* template<class Functor>
* static void OnNativeCall(Functor&& call)
* {
- * RunOnAnotherThread(new ProxyRunnable(mozilla::Move(call)));
+ * RunOnAnotherThread(new ProxyRunnable(std::move(call)));
* }
* };
*/
namespace detail {
// ProxyArg is used to handle JNI ref arguments for proxies. Because a proxied
// call may happen outside of the original JNI native call, we must save all
@@ -531,34 +531,34 @@ struct Dispatcher
// For a static method, do not forward the "this arg" (i.e. the class
// local ref) if the implementation does not request it. This saves us
// a pair of calls to add/delete global ref.
auto proxy = ProxyNativeCall<Impl, typename Traits::Owner, IsStatic,
HasThisArg, Args...>(
(HasThisArg || !IsStatic) ? thisArg : nullptr,
Forward<ProxyArgs>(args)...);
DispatchToGeckoPriorityQueue(
- NS_NewRunnableFunction("PriorityNativeCall", Move(proxy)));
+ NS_NewRunnableFunction("PriorityNativeCall", std::move(proxy)));
}
template<class Traits, bool IsStatic = Traits::isStatic,
typename ThisArg, typename... ProxyArgs>
static typename EnableIf<
Traits::dispatchTarget == DispatchTarget::GECKO, void>::Type
Run(ThisArg thisArg, ProxyArgs&&... args)
{
// For a static method, do not forward the "this arg" (i.e. the class
// local ref) if the implementation does not request it. This saves us
// a pair of calls to add/delete global ref.
auto proxy = ProxyNativeCall<Impl, typename Traits::Owner, IsStatic,
HasThisArg, Args...>(
(HasThisArg || !IsStatic) ? thisArg : nullptr,
Forward<ProxyArgs>(args)...);
NS_DispatchToMainThread(
- NS_NewRunnableFunction("GeckoNativeCall", Move(proxy)));
+ NS_NewRunnableFunction("GeckoNativeCall", std::move(proxy)));
}
template<class Traits, bool IsStatic = false, typename... ProxyArgs>
static typename EnableIf<
Traits::dispatchTarget == DispatchTarget::CURRENT, void>::Type
Run(ProxyArgs&&... args)
{
MOZ_CRASH("Unreachable code");
@@ -824,17 +824,17 @@ protected:
return NativePtr<Impl>::Set(instance, static_cast<Impl*>(ptr));
}
static void AttachNative(const typename Cls::LocalRef& instance,
UniquePtr<Impl>&& ptr)
{
static_assert(NativePtrPicker<Impl>::value == NativePtrType::OWNING,
"Use another AttachNative for WeakPtr or RefPtr usage");
- return NativePtr<Impl>::Set(instance, mozilla::Move(ptr));
+ return NativePtr<Impl>::Set(instance, std::move(ptr));
}
static void AttachNative(const typename Cls::LocalRef& instance, Impl* ptr)
{
static_assert(NativePtrPicker<Impl>::value == NativePtrType::REFPTR,
"Use another AttachNative for non-RefPtr usage");
return NativePtr<Impl>::Set(instance, ptr);
}
--- a/widget/android/jni/Refs.h
+++ b/widget/android/jni/Refs.h
@@ -546,24 +546,24 @@ public:
LocalRef<Cls>& operator=(const Ref& ref) &
{
LocalRef<Cls> newRef(Ctx::mEnv, ref);
return swap(newRef);
}
LocalRef<Cls>& operator=(LocalRef<GenericObject>&& ref) &
{
- LocalRef<Cls> newRef(mozilla::Move(ref));
+ LocalRef<Cls> newRef(std::move(ref));
return swap(newRef);
}
template<class C>
LocalRef<Cls>& operator=(GenericLocalRef<C>&& ref) &
{
- LocalRef<Cls> newRef(mozilla::Move(ref));
+ LocalRef<Cls> newRef(std::move(ref));
return swap(newRef);
}
LocalRef<Cls>& operator=(decltype(nullptr)) &
{
LocalRef<Cls> newRef(Ctx::mEnv, nullptr);
return swap(newRef);
}
@@ -1048,17 +1048,17 @@ private:
public:
explicit ReturnToLocal(LocalRef<Cls>* ref) : localRef(ref) {}
operator LocalRef<Object>*() { return &objRef; }
~ReturnToLocal()
{
if (objRef) {
- *localRef = mozilla::Move(objRef);
+ *localRef = std::move(objRef);
}
}
};
template<class Cls>
ReturnToLocal<Cls> ReturnTo(LocalRef<Cls>* ref)
{
return ReturnToLocal<Cls>(ref);
@@ -1080,17 +1080,17 @@ private:
public:
explicit ReturnToGlobal(GlobalRef<Cls>* ref) : globalRef(ref) {}
operator LocalRef<Object>*() { return &objRef; }
operator LocalRef<Cls>*() { return &clsRef; }
~ReturnToGlobal()
{
if (objRef) {
- *globalRef = (clsRef = mozilla::Move(objRef));
+ *globalRef = (clsRef = std::move(objRef));
} else if (clsRef) {
*globalRef = clsRef;
}
}
};
template<class Cls>
ReturnToGlobal<Cls> ReturnTo(GlobalRef<Cls>* ref)
--- a/widget/android/jni/Utils.cpp
+++ b/widget/android/jni/Utils.cpp
@@ -296,17 +296,17 @@ void DispatchToGeckoPriorityQueue(alread
class RunnableEvent : public nsAppShell::Event
{
nsCOMPtr<nsIRunnable> mCall;
public:
explicit RunnableEvent(already_AddRefed<nsIRunnable> aCall) : mCall(aCall) {}
void Run() override { NS_ENSURE_SUCCESS_VOID(mCall->Run()); }
};
- nsAppShell::PostEvent(MakeUnique<RunnableEvent>(Move(aCall)));
+ nsAppShell::PostEvent(MakeUnique<RunnableEvent>(std::move(aCall)));
}
bool IsFennec()
{
return sIsFennec;
}
int GetAPIVersion()
--- a/widget/android/nsAppShell.cpp
+++ b/widget/android/nsAppShell.cpp
@@ -768,23 +768,23 @@ nsAppShell::SyncRunEvent(Event&& event,
}
event.Run();
finished = true;
mozilla::MutexAutoLock shellLock(*sAppShellLock);
appShell->mSyncRunFinished.NotifyAll();
};
UniquePtr<Event> runAndNotifyEvent = mozilla::MakeUnique<
- LambdaEvent<decltype(runAndNotify)>>(mozilla::Move(runAndNotify));
+ LambdaEvent<decltype(runAndNotify)>>(std::move(runAndNotify));
if (eventFactory) {
- runAndNotifyEvent = (*eventFactory)(mozilla::Move(runAndNotifyEvent));
+ runAndNotifyEvent = (*eventFactory)(std::move(runAndNotifyEvent));
}
- appShell->mEventQueue.Post(mozilla::Move(runAndNotifyEvent));
+ appShell->mEventQueue.Post(std::move(runAndNotifyEvent));
while (!finished && MOZ_LIKELY(sAppShell && !sAppShell->mSyncRunQuit)) {
appShell->mSyncRunFinished.Wait();
}
}
already_AddRefed<nsIURI>
nsAppShell::ResolveURI(const nsCString& aUriStr)
--- a/widget/android/nsAppShell.h
+++ b/widget/android/nsAppShell.h
@@ -72,28 +72,28 @@ public:
template<typename T>
class LambdaEvent : public Event
{
protected:
T lambda;
public:
- explicit LambdaEvent(T&& l) : lambda(mozilla::Move(l)) {}
+ explicit LambdaEvent(T&& l) : lambda(std::move(l)) {}
void Run() override { return lambda(); }
};
class ProxyEvent : public Event
{
protected:
mozilla::UniquePtr<Event> baseEvent;
public:
explicit ProxyEvent(mozilla::UniquePtr<Event>&& event)
- : baseEvent(mozilla::Move(event))
+ : baseEvent(std::move(event))
{}
void PostTo(mozilla::LinkedList<Event>& queue) override
{
baseEvent->PostTo(queue);
}
void Run() override
@@ -122,30 +122,30 @@ public:
// e.g. PostEvent(mozilla::MakeUnique<MyEvent>());
template<typename T, typename D>
static void PostEvent(mozilla::UniquePtr<T, D>&& event)
{
mozilla::MutexAutoLock lock(*sAppShellLock);
if (!sAppShell) {
return;
}
- sAppShell->mEventQueue.Post(mozilla::Move(event));
+ sAppShell->mEventQueue.Post(std::move(event));
}
// Post a event that will call a lambda
// e.g. PostEvent([=] { /* do something */ });
template<typename T>
static void PostEvent(T&& lambda)
{
mozilla::MutexAutoLock lock(*sAppShellLock);
if (!sAppShell) {
return;
}
sAppShell->mEventQueue.Post(mozilla::MakeUnique<LambdaEvent<T>>(
- mozilla::Move(lambda)));
+ std::move(lambda)));
}
// Post a event and wait for it to finish running on the Gecko thread.
static void SyncRunEvent(Event&& event,
mozilla::UniquePtr<Event>(*eventFactory)(
mozilla::UniquePtr<Event>&&) = nullptr);
template<typename T> static
@@ -239,28 +239,28 @@ protected:
nsAppShell::RecordLatencies();
#endif
lock.Wait();
}
// Ownership of event object transfers to the return value.
mozilla::UniquePtr<Event> event(mQueue.popFirst());
if (!event || !event->mPostTime) {
- return Move(event);
+ return std::move(event);
}
#ifdef EARLY_BETA_OR_EARLIER
const size_t latencyType = (event->ActivityType() ==
Event::Type::kUIActivity) ? LATENCY_UI : LATENCY_OTHER;
const uint64_t latency = Event::GetTime() - event->mPostTime;
sLatencyCount[latencyType]++;
sLatencyTime[latencyType] += latency;
#endif
- return Move(event);
+ return std::move(event);
}
} mEventQueue;
mozilla::CondVar mSyncRunFinished;
bool mSyncRunQuit;
bool mAllowCoalescingTouches;
--- a/widget/android/nsWindow.cpp
+++ b/widget/android/nsWindow.cpp
@@ -139,23 +139,23 @@ class nsWindow::WindowEvent : public Run
Lambda mLambda;
const InstanceType mInstance;
public:
WindowEvent(Lambda&& aLambda,
InstanceType&& aInstance)
: Runnable("nsWindowEvent")
- , mLambda(mozilla::Move(aLambda))
+ , mLambda(std::move(aLambda))
, mInstance(Forward<InstanceType>(aInstance))
{}
explicit WindowEvent(Lambda&& aLambda)
: Runnable("nsWindowEvent")
- , mLambda(mozilla::Move(aLambda))
+ , mLambda(std::move(aLambda))
, mInstance(mLambda.GetThisArg())
{}
NS_IMETHOD Run() override
{
if (!IsStaleCall()) {
mLambda();
}
@@ -178,17 +178,17 @@ namespace {
CallAttachNative(Instance aInstance, Impl* aImpl)
{
Impl::AttachNative(aInstance, UniquePtr<Impl>(aImpl));
}
template<class Lambda> bool
DispatchToUiThread(const char* aName, Lambda&& aLambda) {
if (RefPtr<nsThread> uiThread = GetAndroidUiThread()) {
- uiThread->Dispatch(NS_NewRunnableFunction(aName, Move(aLambda)));
+ uiThread->Dispatch(NS_NewRunnableFunction(aName, std::move(aLambda)));
return true;
}
return false;
}
} // namespace
template<class Impl>
template<class Instance, typename... Args> void
@@ -250,17 +250,17 @@ public:
typedef GeckoSession::Window::Natives<GeckoViewSupport> Base;
typedef SupportsWeakPtr<GeckoViewSupport> SupportsWeakPtr;
MOZ_DECLARE_WEAKREFERENCE_TYPENAME(GeckoViewSupport);
template<typename Functor>
static void OnNativeCall(Functor&& aCall)
{
- NS_DispatchToMainThread(new WindowEvent<Functor>(mozilla::Move(aCall)));
+ NS_DispatchToMainThread(new WindowEvent<Functor>(std::move(aCall)));
}
GeckoViewSupport(nsWindow* aWindow,
const GeckoSession::Window::LocalRef& aInstance)
: window(*aWindow)
, mGeckoViewWindow(aInstance)
{
Base::AttachNative(aInstance, static_cast<SupportsWeakPtr*>(this));
@@ -326,17 +326,17 @@ class nsWindow::NPZCSupport final
class InputEvent final : public nsAppShell::Event
{
PanZoomController::GlobalRef mNPZC;
Lambda mLambda;
public:
InputEvent(const NPZCSupport* aNPZCSupport, Lambda&& aLambda)
: mNPZC(aNPZCSupport->mNPZC)
- , mLambda(mozilla::Move(aLambda))
+ , mLambda(std::move(aLambda))
{}
void Run() override
{
MOZ_ASSERT(NS_IsMainThread());
JNIEnv* const env = jni::GetGeckoThreadEnv();
NPZCSupport* npzcSupport = GetNative(
@@ -359,17 +359,17 @@ class nsWindow::NPZCSupport final
}
};
template<typename Lambda>
void PostInputEvent(Lambda&& aLambda)
{
// Use priority queue for input events.
nsAppShell::PostEvent(MakeUnique<InputEvent<Lambda>>(
- this, mozilla::Move(aLambda)));
+ this, std::move(aLambda)));
}
public:
typedef PanZoomController::Natives<NPZCSupport> Base;
NPZCSupport(NativePtr<NPZCSupport>* aPtr, nsWindow* aWindow,
const PanZoomController::LocalRef& aNPZC)
: mWindow(aPtr, aWindow)
@@ -434,17 +434,17 @@ public:
PanZoomController::GlobalRef npzc = mNPZC;
RefPtr<nsThread> uiThread = GetAndroidUiThread();
if (!uiThread) {
return;
}
uiThread->Dispatch(NewRunnableFunction(
"OnDetachRunnable",
static_cast<void(*)(const NPZCRef&)>(callDestroy),
- mozilla::Move(npzc)), nsIThread::DISPATCH_NORMAL);
+ std::move(npzc)), nsIThread::DISPATCH_NORMAL);
}
const PanZoomController::Ref& GetJavaNPZC() const
{
return mNPZC;
}
public:
@@ -792,21 +792,21 @@ class nsWindow::LayerViewSupport final
// a different type. So implement LayerViewEvent as a ProxyEvent.
class LayerViewEvent final : public nsAppShell::ProxyEvent
{
using Event = nsAppShell::Event;
public:
static UniquePtr<Event> MakeEvent(UniquePtr<Event>&& event)
{
- return MakeUnique<LayerViewEvent>(mozilla::Move(event));
+ return MakeUnique<LayerViewEvent>(std::move(event));
}
explicit LayerViewEvent(UniquePtr<Event>&& event)
- : nsAppShell::ProxyEvent(mozilla::Move(event))
+ : nsAppShell::ProxyEvent(std::move(event))
{}
void PostTo(LinkedList<Event>& queue) override
{
// Give priority to compositor events, but keep in order with
// existing compositor events.
nsAppShell::Event* event = queue.getFirst();
while (event && event->HasSameTypeAs(this)) {
@@ -952,17 +952,17 @@ public:
mCompositorPaused = false;
class OnResumedEvent : public nsAppShell::Event
{
LayerSession::Compositor::GlobalRef mCompositor;
public:
explicit OnResumedEvent(LayerSession::Compositor::GlobalRef&& aCompositor)
- : mCompositor(mozilla::Move(aCompositor))
+ : mCompositor(std::move(aCompositor))
{}
void Run() override
{
MOZ_ASSERT(NS_IsMainThread());
JNIEnv* const env = jni::GetGeckoThreadEnv();
LayerViewSupport* const lvs = GetNative(
@@ -2315,12 +2315,12 @@ nsWindow::UpdateRootFrameMetrics(const S
}
}
void
nsWindow::RecvScreenPixels(Shmem&& aMem, const ScreenIntSize& aSize)
{
MOZ_ASSERT(AndroidBridge::IsJavaUiThread());
if (NativePtr<LayerViewSupport>::Locked lvs{mLayerViewSupport}) {
- lvs->RecvScreenPixels(mozilla::Move(aMem), aSize);
+ lvs->RecvScreenPixels(std::move(aMem), aSize);
}
}
--- a/widget/android/nsWindow.h
+++ b/widget/android/nsWindow.h
@@ -224,17 +224,17 @@ public:
virtual nsIWidget *GetParent(void) override;
virtual float GetDPI() override;
virtual double GetDefaultScaleInternal() override;
virtual void Show(bool aState) override;
virtual bool IsVisible() const override;
virtual void ConstrainPosition(bool aAllowSlop,
int32_t *aX,
int32_t *aY) override;
- virtual void Move(double aX,
+ virtual void std::move(double aX,
double aY) override;
virtual void Resize(double aWidth,
double aHeight,
bool aRepaint) override;
virtual void Resize(double aX,
double aY,
double aWidth,
double aHeight,
--- a/widget/cocoa/ScreenHelperCocoa.mm
+++ b/widget/cocoa/ScreenHelperCocoa.mm
@@ -130,17 +130,17 @@ ScreenHelperCocoa::RefreshScreens()
NSDictionary *desc = [screen deviceDescription];
if ([desc objectForKey:NSDeviceIsScreen] == nil) {
continue;
}
screens.AppendElement(MakeScreen(screen));
}
ScreenManager& screenManager = ScreenManager::GetSingleton();
- screenManager.Refresh(Move(screens));
+ screenManager.Refresh(std::move(screens));
NS_OBJC_END_TRY_ABORT_BLOCK;
}
NSScreen*
ScreenHelperCocoa::CocoaScreenForScreen(nsIScreen* aScreen)
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
--- a/widget/cocoa/nsChildView.h
+++ b/widget/cocoa/nsChildView.h
@@ -318,17 +318,17 @@ public:
virtual void Show(bool aState) override;
virtual bool IsVisible() const override;
virtual void SetParent(nsIWidget* aNewParent) override;
virtual nsIWidget* GetParent(void) override;
virtual float GetDPI() override;
- virtual void Move(double aX, double aY) override;
+ virtual void std::move(double aX, double aY) override;
virtual void Resize(double aWidth, double aHeight, bool aRepaint) override;
virtual void Resize(double aX, double aY,
double aWidth, double aHeight, bool aRepaint) override;
virtual void Enable(bool aState) override;
virtual bool IsEnabled() const override;
virtual nsresult SetFocus(bool aRaise) override;
virtual LayoutDeviceIntRect GetBounds() override;
--- a/widget/cocoa/nsCocoaWindow.h
+++ b/widget/cocoa/nsCocoaWindow.h
@@ -231,17 +231,17 @@ public:
virtual LayoutDeviceIntSize
ClientToWindowSize(const LayoutDeviceIntSize& aClientSize) override;
virtual void* GetNativeData(uint32_t aDataType) override;
virtual void ConstrainPosition(bool aAllowSlop,
int32_t *aX, int32_t *aY) override;
virtual void SetSizeConstraints(const SizeConstraints& aConstraints) override;
- virtual void Move(double aX, double aY) override;
+ virtual void std::move(double aX, double aY) override;
virtual void SetSizeMode(nsSizeMode aMode) override;
virtual void SuppressAnimation(bool aSuppress) override;
virtual void HideWindowChrome(bool aShouldHide) override;
void WillEnterFullScreen(bool aFullScreen);
void EnteredFullScreen(bool aFullScreen, bool aNativeMode = true);
virtual bool PrepareForFullscreenTransition(nsISupports** aData) override;
virtual void PerformFullscreenTransition(FullscreenTransitionStage aStage,
--- a/widget/cocoa/nsDeviceContextSpecX.mm
+++ b/widget/cocoa/nsDeviceContextSpecX.mm
@@ -269,15 +269,15 @@ already_AddRefed<PrintTarget> nsDeviceCo
NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(mTempFile));
NS_ENSURE_SUCCESS(rv, nullptr);
nsAutoCString tempPath("tmp-printing.pdf");
mTempFile->AppendNative(tempPath);
rv = mTempFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600);
NS_ENSURE_SUCCESS(rv, nullptr);
mTempFile->GetNativePath(tempPath);
auto stream = MakeUnique<SkFILEWStream>(tempPath.get());
- return PrintTargetSkPDF::CreateOrNull(Move(stream), size);
+ return PrintTargetSkPDF::CreateOrNull(std::move(stream), size);
}
#endif
return PrintTargetCG::CreateOrNull(mPrintSession, mPageFormat,
mPrintSettings, size);
}
--- a/widget/cocoa/nsMenuX.mm
+++ b/widget/cocoa/nsMenuX.mm
@@ -238,17 +238,17 @@ nsresult nsMenuX::AddMenuItem(nsMenuItem
nsMenuX* nsMenuX::AddMenu(UniquePtr<nsMenuX> aMenu)
{
NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
// aMenu transfers ownership to mMenuObjectsArray and becomes nullptr, so
// we need to keep a raw pointer to access it conveniently.
nsMenuX* menu = aMenu.get();
- mMenuObjectsArray.AppendElement(Move(aMenu));
+ mMenuObjectsArray.AppendElement(std::move(aMenu));
if (nsMenuUtilsX::NodeIsHiddenOrCollapsed(menu->Content())) {
return menu;
}
++mVisibleItemsCount;
// We have to add a menu item and then associate the menu with it
@@ -553,17 +553,17 @@ void nsMenuX::LoadSubMenu(nsIContent* in
return;
nsresult rv = menu->Create(this, mMenuGroupOwner, inMenuContent);
if (NS_FAILED(rv))
return;
// |menu|'s ownership is transfer to AddMenu but, if it is successfully
// added, we can access it via the returned raw pointer.
- nsMenuX* menu_ptr = AddMenu(Move(menu));
+ nsMenuX* menu_ptr = AddMenu(std::move(menu));
// This needs to happen after the nsIMenu object is inserted into
// our item array in AddMenu()
if (menu_ptr) {
menu_ptr->SetupIcon();
}
}
--- a/widget/gtk/ScreenHelperGTK.cpp
+++ b/widget/gtk/ScreenHelperGTK.cpp
@@ -192,13 +192,13 @@ ScreenHelperGTK::RefreshScreens()
MOZ_LOG(sScreenLog, LogLevel::Debug,
("GDK reports %d screens", numScreens));
for (gint i = 0; i < numScreens; i++) {
screenList.AppendElement(MakeScreen(defaultScreen, i));
}
ScreenManager& screenManager = ScreenManager::GetSingleton();
- screenManager.Refresh(Move(screenList));
+ screenManager.Refresh(std::move(screenList));
}
} // namespace widget
} // namespace mozilla
--- a/widget/gtk/nsWindow.cpp
+++ b/widget/gtk/nsWindow.cpp
@@ -2359,17 +2359,17 @@ nsWindow::OnConfigureEvent(GtkWidget *aW
NS_ASSERTION(GTK_IS_WINDOW(aWidget),
"Configure event on widget that is not a GtkWindow");
if (gtk_window_get_window_type(GTK_WINDOW(aWidget)) == GTK_WINDOW_POPUP) {
// Override-redirect window
//
// These windows should not be moved by the window manager, and so any
// change in position is a result of our direction. mBounds has
- // already been set in Move() or Resize(), and that is more
+ // already been set in std::move() or Resize(), and that is more
// up-to-date than the position in the ConfigureNotify event if the
// event is from an earlier window move.
//
// Skipping the WindowMoved call saves context menus from an infinite
// loop when nsXULPopupManager::PopupMoved moves the window to the new
// position and nsMenuPopupFrame::SetPopupPosition adds
// offsetForContextMenu on each iteration.
return FALSE;
--- a/widget/gtk/nsWindow.h
+++ b/widget/gtk/nsWindow.h
@@ -126,17 +126,17 @@ public:
mozilla::DesktopToLayoutDeviceScale GetDesktopToDeviceScale() override;
virtual void SetParent(nsIWidget* aNewParent) override;
virtual void SetModal(bool aModal) override;
virtual bool IsVisible() const override;
virtual void ConstrainPosition(bool aAllowSlop,
int32_t *aX,
int32_t *aY) override;
virtual void SetSizeConstraints(const SizeConstraints& aConstraints) override;
- virtual void Move(double aX,
+ virtual void std::move(double aX,
double aY) override;
virtual void Show (bool aState) override;
virtual void Resize (double aWidth,
double aHeight,
bool aRepaint) override;
virtual void Resize (double aX,
double aY,
double aWidth,
--- a/widget/headless/HeadlessScreenHelper.cpp
+++ b/widget/headless/HeadlessScreenHelper.cpp
@@ -35,13 +35,13 @@ HeadlessScreenHelper::HeadlessScreenHelp
LayoutDeviceIntRect rect = GetScreenRect();
RefPtr<Screen> ret = new Screen(rect, rect,
24, 24,
DesktopToLayoutDeviceScale(),
CSSToLayoutDeviceScale(),
96.0f);
screenList.AppendElement(ret.forget());
ScreenManager& screenManager = ScreenManager::GetSingleton();
- screenManager.Refresh(Move(screenList));
+ screenManager.Refresh(std::move(screenList));
}
} // namespace widget
} // namespace mozilla
--- a/widget/headless/HeadlessWidget.h
+++ b/widget/headless/HeadlessWidget.h
@@ -73,17 +73,17 @@ public:
virtual nsIWidget* GetTopLevelWidget() override;
virtual void GetCompositorWidgetInitData(mozilla::widget::CompositorWidgetInitData* aInitData) override;
virtual void Destroy() override;
virtual void Show(bool aState) override;
virtual bool IsVisible() const override;
- virtual void Move(double aX, double aY) override;
+ virtual void std::move(double aX, double aY) override;
virtual void Resize(double aWidth,
double aHeight,
bool aRepaint) override;
virtual void Resize(double aX,
double aY,
double aWidth,
double aHeight,
bool aRepaint) override;
--- a/widget/nsBaseWidget.cpp
+++ b/widget/nsBaseWidget.cpp
@@ -967,17 +967,17 @@ void nsBaseWidget::ConfigureAPZCTreeMana
MOZ_ASSERT(NS_IsMainThread());
APZThreadUtils::RunOnControllerThread(NewRunnableMethod<uint64_t, bool>(
"layers::IAPZCTreeManager::ContentReceivedInputBlock",
treeManager,
&IAPZCTreeManager::ContentReceivedInputBlock,
aInputBlockId,
aPreventDefault));
});
- mAPZEventState = new APZEventState(this, mozilla::Move(callback));
+ mAPZEventState = new APZEventState(this, std::move(callback));
mSetAllowedTouchBehaviorCallback = [treeManager](uint64_t aInputBlockId,
const nsTArray<TouchBehaviorFlags>& aFlags)
{
MOZ_ASSERT(NS_IsMainThread());
APZThreadUtils::RunOnControllerThread(
NewRunnableMethod<uint64_t,
StoreCopyPassByLRef<nsTArray<TouchBehaviorFlags>>>(
@@ -1558,19 +1558,19 @@ void
nsBaseWidget::MoveClient(double aX, double aY)
{
LayoutDeviceIntPoint clientOffset(GetClientOffset());
// GetClientOffset returns device pixels; scale back to desktop pixels
// if that's what this widget uses for the Move/Resize APIs
if (BoundsUseDesktopPixels()) {
DesktopPoint desktopOffset = clientOffset / GetDesktopToDeviceScale();
- Move(aX - desktopOffset.x, aY - desktopOffset.y);
+ std::move(aX - desktopOffset.x, aY - desktopOffset.y);
} else {
- Move(aX - clientOffset.x, aY - clientOffset.y);
+ std::move(aX - clientOffset.x, aY - clientOffset.y);
}
}
void
nsBaseWidget::ResizeClient(double aWidth, double aHeight, bool aRepaint)
{
NS_ASSERTION((aWidth >=0) , "Negative width passed to ResizeClient");
NS_ASSERTION((aHeight >=0), "Negative height passed to ResizeClient");
--- a/widget/nsIWidget.h
+++ b/widget/nsIWidget.h
@@ -728,17 +728,17 @@ class nsIWidget : public nsISupports
*
* Coordinates refer to the top-left of the widget. For toplevel windows
* with decorations, this is the top-left of the titlebar and frame .
*
* @param aX the new x position expressed in the parent's coordinate system
* @param aY the new y position expressed in the parent's coordinate system
*
**/
- virtual void Move(double aX, double aY) = 0;
+ virtual void std::move(double aX, double aY) = 0;
/**
* Reposition this widget so that the client area has the given offset.
*
* @param aX the new x offset of the client area expressed as an
* offset from the origin of the client area of the parent
* widget (for root widgets and popup widgets it is in
* screen coordinates)
--- a/widget/uikit/nsWindow.h
+++ b/widget/uikit/nsWindow.h
@@ -44,17 +44,17 @@ public:
return mVisible;
}
virtual nsresult SetFocus(bool aState=false) override;
virtual LayoutDeviceIntPoint WidgetToScreenOffset() override;
virtual void SetBackgroundColor(const nscolor &aColor) override;
virtual void* GetNativeData(uint32_t aDataType) override;
- virtual void Move(double aX, double aY) override;
+ virtual void std::move(double aX, double aY) override;
virtual void SetSizeMode(nsSizeMode aMode) override;
void EnteredFullScreen(bool aFullScreen);
virtual void Resize(double aWidth, double aHeight, bool aRepaint) override;
virtual void Resize(double aX, double aY, double aWidth, double aHeight, bool aRepaint) override;
virtual LayoutDeviceIntRect GetScreenBounds() override;
void ReportMoveEvent();
void ReportSizeEvent();
void ReportSizeModeEvent(nsSizeMode aMode);
--- a/widget/windows/AudioSession.cpp
+++ b/widget/windows/AudioSession.cpp
@@ -318,17 +318,17 @@ AudioSession::StopInternal()
mAudioSessionControl->UnregisterAudioSessionNotification(this);
}
// Win7 is the only Windows version supported before Win8.
if (mAudioSessionControl && !IsWin8OrLater()) {
// bug 1419488: Avoid hanging due to Win7 race condition when destroying
// AudioSessionControl. We do that by Moving the AudioSessionControl
// to a worker thread (that we never 'join') for destruction.
- SpawnASCReleaseThread(Move(mAudioSessionControl));
+ SpawnASCReleaseThread(std::move(mAudioSessionControl));
} else {
mAudioSessionControl = nullptr;
}
}
nsresult
AudioSession::Stop()
{
--- a/widget/windows/JumpListBuilder.cpp
+++ b/widget/windows/JumpListBuilder.cpp
@@ -478,17 +478,17 @@ NS_IMETHODIMP JumpListBuilder::CommitLis
RefPtr<detail::DoneCommitListBuildCallback> callback =
new detail::DoneCommitListBuildCallback(aCallback, this);
// The builder has a strong reference in the callback already, so we do not
// need to do it for this runnable again.
RefPtr<nsIRunnable> event =
NewNonOwningRunnableMethod<RefPtr<detail::DoneCommitListBuildCallback>>
("JumpListBuilder::DoCommitListBuild", this,
- &JumpListBuilder::DoCommitListBuild, Move(callback));
+ &JumpListBuilder::DoCommitListBuild, std::move(callback));
Unused << mIOThread->Dispatch(event, NS_DISPATCH_NORMAL);
return NS_OK;
}
void JumpListBuilder::DoCommitListBuild(RefPtr<detail::DoneCommitListBuildCallback> aCallback)
{
ReentrantMonitorAutoEnter lock(mMonitor);
--- a/widget/windows/PDFiumParent.cpp
+++ b/widget/windows/PDFiumParent.cpp
@@ -39,17 +39,17 @@ PDFiumParent::ActorDestroy(ActorDestroyR
mozilla::ipc::IPCResult
PDFiumParent::RecvConvertToEMFDone(const nsresult& aResult,
mozilla::ipc::Shmem&& aEMFContents)
{
MOZ_ASSERT(aEMFContents.IsReadable());
if (mTarget) {
- mTarget->ConvertToEMFDone(aResult, Move(aEMFContents));
+ mTarget->ConvertToEMFDone(aResult, std::move(aEMFContents));
}
return IPC_OK();
}
void PDFiumParent::EndConversion()
{
// The printing job is done(all pages printed, or print job cancel, or print
--- a/widget/windows/ScreenHelperWin.cpp
+++ b/widget/windows/ScreenHelperWin.cpp
@@ -65,19 +65,19 @@ CollectMonitors(HMONITOR aMon, HDC, LPRE
pixelDepth, contentsScaleFactor.scale, defaultCssScaleFactor.scale,
dpi));
auto screen = new Screen(rect, availRect,
pixelDepth, pixelDepth,
contentsScaleFactor, defaultCssScaleFactor,
dpi);
if (info.dwFlags & MONITORINFOF_PRIMARY) {
// The primary monitor must be the first element of the screen list.
- screens->InsertElementAt(0, Move(screen));
+ screens->InsertElementAt(0, std::move(screen));
} else {
- screens->AppendElement(Move(screen));
+ screens->AppendElement(std::move(screen));
}
return TRUE;
}
void
ScreenHelperWin::RefreshScreens()
{
MOZ_LOG(sScreenLog, LogLevel::Debug, ("Refreshing screens"));
@@ -85,13 +85,13 @@ ScreenHelperWin::RefreshScreens()
AutoTArray<RefPtr<Screen>, 4> screens;
BOOL result = ::EnumDisplayMonitors(nullptr, nullptr,
(MONITORENUMPROC)CollectMonitors,
(LPARAM)&screens);
if (!result) {
NS_WARNING("Unable to EnumDisplayMonitors");
}
ScreenManager& screenManager = ScreenManager::GetSingleton();
- screenManager.Refresh(Move(screens));
+ screenManager.Refresh(std::move(screens));
}
} // namespace widget
} // namespace mozilla
--- a/widget/windows/WinUtils.cpp
+++ b/widget/windows/WinUtils.cpp
@@ -1317,17 +1317,17 @@ AsyncFaviconDataReady::OnComplete(nsIURI
// another thread.
UniquePtr<uint8_t[]> data = SurfaceToPackedBGRA(dataSurface);
if (!data) {
return NS_ERROR_OUT_OF_MEMORY;
}
int32_t stride = 4 * size.width;
// AsyncEncodeAndWriteIcon takes ownership of the heap allocated buffer
- nsCOMPtr<nsIRunnable> event = new AsyncEncodeAndWriteIcon(path, Move(data),
+ nsCOMPtr<nsIRunnable> event = new AsyncEncodeAndWriteIcon(path, std::move(data),
stride,
size.width,
size.height,
mURLShortcut);
mIOThread->Dispatch(event, NS_DISPATCH_NORMAL);
return NS_OK;
}
@@ -1337,17 +1337,17 @@ AsyncFaviconDataReady::OnComplete(nsIURI
AsyncEncodeAndWriteIcon::AsyncEncodeAndWriteIcon(const nsAString &aIconPath,
UniquePtr<uint8_t[]> aBuffer,
uint32_t aStride,
uint32_t aWidth,
uint32_t aHeight,
const bool aURLShortcut) :
mURLShortcut(aURLShortcut),
mIconPath(aIconPath),
- mBuffer(Move(aBuffer)),
+ mBuffer(std::move(aBuffer)),
mStride(aStride),
mWidth(aWidth),
mHeight(aHeight)
{
}
NS_IMETHODIMP AsyncEncodeAndWriteIcon::Run()
{
--- a/widget/windows/nsDeviceContextSpecWin.cpp
+++ b/widget/windows/nsDeviceContextSpecWin.cpp
@@ -222,17 +222,17 @@ already_AddRefed<PrintTarget> nsDeviceCo
IntSize size = IntSize::Truncate(width, height);
if (mOutputFormat == nsIPrintSettings::kOutputFormatPDF) {
nsString filename;
mPrintSettings->GetToFileName(filename);
nsAutoCString printFile(NS_ConvertUTF16toUTF8(filename).get());
auto skStream = MakeUnique<SkFILEWStream>(printFile.get());
- return PrintTargetSkPDF::CreateOrNull(Move(skStream), size);
+ return PrintTargetSkPDF::CreateOrNull(std::move(skStream), size);
}
if (mDevMode) {
NS_WARNING_ASSERTION(!mDriverName.IsEmpty(), "No driver!");
HDC dc = ::CreateDCW(mDriverName.get(), mDeviceName.get(), nullptr, mDevMode);
if (!dc) {
gfxCriticalError(gfxCriticalError::DefaultOptions(false))
<< "Failed to create device context in GetSurfaceForPrinter";
--- a/widget/windows/nsWindow.h
+++ b/widget/windows/nsWindow.h
@@ -123,17 +123,17 @@ public:
}
}
virtual void Show(bool aState) override;
virtual bool IsVisible() const override;
virtual void ConstrainPosition(bool aAllowSlop, int32_t *aX, int32_t *aY) override;
virtual void SetSizeConstraints(const SizeConstraints& aConstraints) override;
virtual const SizeConstraints GetSizeConstraints() override;
- virtual void Move(double aX, double aY) override;
+ virtual void std::move(double aX, double aY) override;
virtual void Resize(double aWidth, double aHeight, bool aRepaint) override;
virtual void Resize(double aX, double aY, double aWidth, double aHeight, bool aRepaint) override;
virtual MOZ_MUST_USE nsresult
BeginResizeDrag(mozilla::WidgetGUIEvent* aEvent,
int32_t aHorizontal,
int32_t aVertical) override;
virtual void PlaceBehind(nsTopLevelWidgetZPlacement aPlacement, nsIWidget *aWidget, bool aActivate) override;
virtual void SetSizeMode(nsSizeMode aMode) override;
--- a/xpcom/base/CycleCollectedJSContext.cpp
+++ b/xpcom/base/CycleCollectedJSContext.cpp
@@ -318,17 +318,17 @@ CycleCollectedJSContext::ProcessStableSt
void
CycleCollectedJSContext::CleanupIDBTransactions(uint32_t aRecursionDepth)
{
MOZ_ASSERT(mJSContext);
MOZ_RELEASE_ASSERT(!mDoingStableStates);
mDoingStableStates = true;
- nsTArray<PendingIDBTransactionData> localQueue = Move(mPendingIDBTransactions);
+ nsTArray<PendingIDBTransactionData> localQueue = std::move(mPendingIDBTransactions);
for (uint32_t i = 0; i < localQueue.Length(); ++i)
{
PendingIDBTransactionData& data = localQueue[i];
if (data.mRecursionDepth != aRecursionDepth) {
continue;
}
@@ -424,17 +424,17 @@ CycleCollectedJSContext::RecursionDepth(
{
return mOwningThread->RecursionDepth();
}
void
CycleCollectedJSContext::RunInStableState(already_AddRefed<nsIRunnable>&& aRunnable)
{
MOZ_ASSERT(mJSContext);
- mStableStateEvents.AppendElement(Move(aRunnable));
+ mStableStateEvents.AppendElement(std::move(aRunnable));
}
void
CycleCollectedJSContext::AddPendingIDBTransaction(already_AddRefed<nsIRunnable>&& aTransaction)
{
MOZ_ASSERT(mJSContext);
PendingIDBTransactionData data;
@@ -450,17 +450,17 @@ CycleCollectedJSContext::AddPendingIDBTr
// XXX bug 1261143
// Recursion depth should be greater than mBaseRecursionDepth,
// or the runnable will stay in the queue forever.
if (data.mRecursionDepth <= mBaseRecursionDepth) {
data.mRecursionDepth = mBaseRecursionDepth + 1;
}
#endif
- mPendingIDBTransactions.AppendElement(Move(data));
+ mPendingIDBTransactions.AppendElement(std::move(data));
}
void
CycleCollectedJSContext::DispatchToMicroTask(
already_AddRefed<MicroTaskRunnable> aRunnable)
{
RefPtr<MicroTaskRunnable> runnable(aRunnable);
--- a/xpcom/base/CycleCollectedJSRuntime.cpp
+++ b/xpcom/base/CycleCollectedJSRuntime.cpp
@@ -931,17 +931,17 @@ public:
}
}
virtual UniquePtr<AbstractTimelineMarker>
Clone() override
{
auto clone = MakeUnique<MinorGCMarker>(GetTracingType(), mReason);
clone->SetCustomTime(GetTime());
- return UniquePtr<AbstractTimelineMarker>(Move(clone));
+ return UniquePtr<AbstractTimelineMarker>(std::move(clone));
}
};
/* static */ void
CycleCollectedJSRuntime::GCNurseryCollectionCallback(JSContext* aContext,
JS::GCNurseryProgress aProgress,
JS::gcreason::Reason aReason)
{
@@ -1634,17 +1634,17 @@ CycleCollectedJSRuntime::ErrorIntercepto
// so nothing such should happen.
nsContentUtils::ExtractErrorValues(cx, value, details.mFilename, &details.mLine, &details.mColumn, details.mMessage);
nsAutoCString stack;
JS::UniqueChars buf = JS::FormatStackDump(cx, nullptr, /* showArgs = */ false, /* showLocals = */ false, /* showThisProps = */ false);
stack.Append(buf.get());
CopyUTF8toUTF16(buf.get(), details.mStack);
- mThrownError.emplace(Move(details));
+ mThrownError.emplace(std::move(details));
}
void
CycleCollectedJSRuntime::ClearRecentDevError()
{
mErrorInterceptor.mThrownError.reset();
}
--- a/xpcom/base/DebuggerOnGCRunnable.cpp
+++ b/xpcom/base/DebuggerOnGCRunnable.cpp
@@ -18,30 +18,30 @@ namespace mozilla {
DebuggerOnGCRunnable::Enqueue(JSContext* aCx, const JS::GCDescription& aDesc)
{
auto gcEvent = aDesc.toGCEvent(aCx);
if (!gcEvent) {
return NS_ERROR_OUT_OF_MEMORY;
}
RefPtr<DebuggerOnGCRunnable> runOnGC =
- new DebuggerOnGCRunnable(Move(gcEvent));
+ new DebuggerOnGCRunnable(std::move(gcEvent));
if (NS_IsMainThread()) {
return SystemGroup::Dispatch(TaskCategory::GarbageCollection, runOnGC.forget());
} else {
return NS_DispatchToCurrentThread(runOnGC);
}
}
NS_IMETHODIMP
DebuggerOnGCRunnable::Run()
{
AutoJSAPI jsapi;
jsapi.Init();
- if (!JS::dbg::FireOnGarbageCollectionHook(jsapi.cx(), Move(mGCData))) {
+ if (!JS::dbg::FireOnGarbageCollectionHook(jsapi.cx(), std::move(mGCData))) {
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
nsresult
DebuggerOnGCRunnable::Cancel()
{
--- a/xpcom/base/DebuggerOnGCRunnable.h
+++ b/xpcom/base/DebuggerOnGCRunnable.h
@@ -15,17 +15,17 @@
namespace mozilla {
// Runnable to fire the SpiderMonkey Debugger API's onGarbageCollection hook.
class DebuggerOnGCRunnable : public CancelableRunnable
{
JS::dbg::GarbageCollectionEvent::Ptr mGCData;
explicit DebuggerOnGCRunnable(JS::dbg::GarbageCollectionEvent::Ptr&& aGCData)
- : CancelableRunnable("DebuggerOnGCRunnable"), mGCData(Move(aGCData))
+ : CancelableRunnable("DebuggerOnGCRunnable"), mGCData(std::move(aGCData))
{ }
public:
static nsresult Enqueue(JSContext* aCx, const JS::GCDescription& aDesc);
NS_DECL_NSIRUNNABLE
nsresult Cancel() override;
};
--- a/xpcom/base/nsCOMPtr.h
+++ b/xpcom/base/nsCOMPtr.h
@@ -118,17 +118,17 @@ dont_AddRef(T* aRawPtr)
{
return already_AddRefed<T>(aRawPtr);
}
template<class T>
inline already_AddRefed<T>&&
dont_AddRef(already_AddRefed<T>&& aAlreadyAddRefedPtr)
{
- return mozilla::Move(aAlreadyAddRefedPtr);
+ return std::move(aAlreadyAddRefedPtr);
}
/*
* An nsCOMPtr_helper transforms commonly called getters into typesafe forms
* that are more convenient to call, and more efficient to use with |nsCOMPtr|s.
* Good candidates for helpers are |QueryInterface()|, |CreateInstance()|, etc.
*
--- a/xpcom/base/nsCycleCollector.cpp
+++ b/xpcom/base/nsCycleCollector.cpp
@@ -1189,17 +1189,17 @@ public:
bool aRemoveChildlessNodes,
bool aAsyncSnowWhiteFreeing,
CC_ForgetSkippableCallback aCb);
MOZ_ALWAYS_INLINE void Put(void* aObject, nsCycleCollectionParticipant* aCp,
nsCycleCollectingAutoRefCnt* aRefCnt)
{
nsPurpleBufferEntry entry(aObject, aRefCnt, aCp);
- Unused << mEntries.Append(Move(entry));
+ Unused << mEntries.Append(std::move(entry));
MOZ_ASSERT(!entry.mRefCnt, "Move didn't work!");
++mCount;
}
void Remove(nsPurpleBufferEntry* aEntry)
{
MOZ_ASSERT(mCount != 0, "must have entries");
--mCount;
--- a/xpcom/base/nsMemoryInfoDumper.cpp
+++ b/xpcom/base/nsMemoryInfoDumper.cpp
@@ -471,17 +471,17 @@ class HandleReportAndFinishReportingCall
: public nsIHandleReportCallback, public nsIFinishReportingCallback
{
public:
NS_DECL_ISUPPORTS
HandleReportAndFinishReportingCallbacks(UniquePtr<JSONWriter> aWriter,
nsIFinishDumpingCallback* aFinishDumping,
nsISupports* aFinishDumpingData)
- : mWriter(Move(aWriter))
+ : mWriter(std::move(aWriter))
, mFinishDumping(aFinishDumping)
, mFinishDumpingData(aFinishDumpingData)
{
}
// This is the callback for nsIHandleReportCallback.
NS_IMETHOD Callback(const nsACString& aProcess, const nsACString& aPath,
int32_t aKind, int32_t aUnits, int64_t aAmount,
@@ -666,17 +666,17 @@ DumpMemoryInfoToFile(
jsonWriter->IntProperty("version", 1);
jsonWriter->BoolProperty("hasMozMallocUsableSize",
mgr->GetHasMozMallocUsableSize());
jsonWriter->StartArrayProperty("reports");
}
RefPtr<HandleReportAndFinishReportingCallbacks>
handleReportAndFinishReporting =
- new HandleReportAndFinishReportingCallbacks(Move(jsonWriter),
+ new HandleReportAndFinishReportingCallbacks(std::move(jsonWriter),
aFinishDumping,
aFinishDumpingData);
rv = mgr->GetReportsExtended(handleReportAndFinishReporting, nullptr,
handleReportAndFinishReporting, nullptr,
aAnonymize,
aMinimizeMemoryUsage,
aDMDIdentifier);
return rv;
--- a/xpcom/build/FileLocation.cpp
+++ b/xpcom/build/FileLocation.cpp
@@ -32,19 +32,19 @@ FileLocation::FileLocation(nsZipArchive*
FileLocation::FileLocation(const FileLocation& aOther)
: mBaseFile(aOther.mBaseFile)
, mBaseZip(aOther.mBaseZip)
, mPath(aOther.mPath)
{
}
FileLocation::FileLocation(FileLocation&& aOther)
- : mBaseFile(Move(aOther.mBaseFile))
- , mBaseZip(Move(aOther.mBaseZip))
- , mPath(Move(aOther.mPath))
+ : mBaseFile(std::move(aOther.mBaseFile))
+ , mBaseZip(std::move(aOther.mBaseZip))
+ , mPath(std::move(aOther.mPath))
{
aOther.mPath.Truncate();
}
FileLocation::FileLocation(const FileLocation& aFile, const char* aPath)
{
if (aFile.IsZip()) {
if (aFile.mBaseFile) {
--- a/xpcom/ds/IncrementalTokenizer.cpp
+++ b/xpcom/ds/IncrementalTokenizer.cpp
@@ -20,17 +20,17 @@ IncrementalTokenizer::IncrementalTokeniz
uint32_t aRawMinBuffered)
: TokenizerBase(aWhitespaces, aAdditionalWordChars)
#ifdef DEBUG
, mConsuming(false)
#endif
, mNeedMoreInput(false)
, mRollback(false)
, mInputCursor(0)
- , mConsumer(Move(aConsumer))
+ , mConsumer(std::move(aConsumer))
{
mInputFinished = false;
mMinRawDelivery = aRawMinBuffered;
}
nsresult IncrementalTokenizer::FeedInput(const nsACString & aInput)
{
NS_ENSURE_TRUE(mConsumer, NS_ERROR_NOT_INITIALIZED);
--- a/xpcom/ds/PLDHashTable.cpp
+++ b/xpcom/ds/PLDHashTable.cpp
@@ -231,22 +231,22 @@ PLDHashTable::operator=(PLDHashTable&& a
MOZ_RELEASE_ASSERT(mOps == aOther.mOps);
MOZ_RELEASE_ASSERT(mEntrySize == aOther.mEntrySize);
// Reconstruct |this|.
this->~PLDHashTable();
new (KnownNotNull, this) PLDHashTable(aOther.mOps, aOther.mEntrySize, 0);
// Move non-const pieces over.
- mHashShift = Move(aOther.mHashShift);
- mEntryCount = Move(aOther.mEntryCount);
- mRemovedCount = Move(aOther.mRemovedCount);
+ mHashShift = std::move(aOther.mHashShift);
+ mEntryCount = std::move(aOther.mEntryCount);
+ mRemovedCount = std::move(aOther.mRemovedCount);
mEntryStore.Set(aOther.mEntryStore.Get(), &mGeneration);
#ifdef DEBUG
- mChecker = Move(aOther.mChecker);
+ mChecker = std::move(aOther.mChecker);
#endif
// Clear up |aOther| so its destruction will be a no-op.
{
#ifdef DEBUG
AutoDestructorOp op(mChecker);
#endif
aOther.mEntryStore.Set(nullptr, &aOther.mGeneration);
--- a/xpcom/ds/PLDHashTable.h
+++ b/xpcom/ds/PLDHashTable.h
@@ -292,17 +292,17 @@ public:
: mOps(aOther.mOps)
, mEntryStore()
, mGeneration(0)
, mEntrySize(aOther.mEntrySize)
#ifdef DEBUG
, mChecker()
#endif
{
- *this = mozilla::Move(aOther);
+ *this = std::move(aOther);
}
PLDHashTable& operator=(PLDHashTable&& aOther);
~PLDHashTable();
// This should be used rarely.
const PLDHashTableOps* Ops() const { return mOps; }
--- a/xpcom/ds/nsBaseHashtable.h
+++ b/xpcom/ds/nsBaseHashtable.h
@@ -156,29 +156,29 @@ public:
/**
* Put a new value for the associated key
* @param aKey the key to put
* @param aData the new data
*/
void Put(KeyType aKey, UserDataType&& aData)
{
- if (!Put(aKey, mozilla::Move(aData), mozilla::fallible)) {
+ if (!Put(aKey, std::move(aData), mozilla::fallible)) {
NS_ABORT_OOM(this->mTable.EntrySize() * this->mTable.EntryCount());
}
}
MOZ_MUST_USE bool Put(KeyType aKey, UserDataType&& aData, const fallible_t&)
{
EntryType* ent = this->PutEntry(aKey, mozilla::fallible);
if (!ent) {
return false;
}
- ent->mData = mozilla::Move(aData);
+ ent->mData = std::move(aData);
return true;
}
/**
* Remove the entry associated with aKey (if any), optionally _moving_ its
* current value into *aData. Return true if found.
* @param aKey the key to remove from the hashtable
@@ -186,23 +186,23 @@ public:
* found, *aData will be assigned a default-constructed value
* (i.e. reset to zero or nullptr for primitive types).
* @return true if an entry for aKey was found (and removed)
*/
bool Remove(KeyType aKey, DataType* aData = nullptr)
{
if (auto* ent = this->GetEntry(aKey)) {
if (aData) {
- *aData = mozilla::Move(ent->mData);
+ *aData = std::move(ent->mData);
}
this->RemoveEntry(ent);
return true;
}
if (aData) {
- *aData = mozilla::Move(DataType());
+ *aData = std::move(DataType());
}
return false;
}
struct LookupResult {
private:
EntryType* mEntry;
nsBaseHashtable& mTable;
@@ -450,18 +450,18 @@ nsBaseHashtableET<KeyClass, DataType>::n
: KeyClass(aKey)
, mData()
{
}
template<class KeyClass, class DataType>
nsBaseHashtableET<KeyClass, DataType>::nsBaseHashtableET(
nsBaseHashtableET<KeyClass, DataType>&& aToMove)
- : KeyClass(mozilla::Move(aToMove))
- , mData(mozilla::Move(aToMove.mData))
+ : KeyClass(std::move(aToMove))
+ , mData(std::move(aToMove.mData))
{
}
template<class KeyClass, class DataType>
nsBaseHashtableET<KeyClass, DataType>::~nsBaseHashtableET()
{
}
--- a/xpcom/ds/nsCOMArray.h
+++ b/xpcom/ds/nsCOMArray.h
@@ -81,17 +81,17 @@ protected:
return InsertObjectAt(aObject, Count());
}
void AppendElement(nsISupports* aElement)
{
InsertElementAt(Length(), aElement);
}
void AppendElement(already_AddRefed<nsISupports> aElement)
{
- InsertElementAt(Length(), mozilla::Move(aElement));
+ InsertElementAt(Length(), std::move(aElement));
}
bool AppendObjects(const nsCOMArray_base& aObjects)
{
return InsertObjectsAt(aObjects, Count());
}
void AppendElements(const nsCOMArray_base& aElements)
{
@@ -359,17 +359,17 @@ public:
}
// nsTArray-compatible version
void AppendElement(T* aElement)
{
nsCOMArray_base::AppendElement(aElement);
}
void AppendElement(already_AddRefed<T> aElement)
{
- nsCOMArray_base::AppendElement(mozilla::Move(aElement));
+ nsCOMArray_base::AppendElement(std::move(aElement));
}
// append objects, growing the array as necessary
bool AppendObjects(const nsCOMArray<T>& aObjects)
{
return nsCOMArray_base::AppendObjects(aObjects);
}
// nsTArray-compatible version
--- a/xpcom/ds/nsDataHashtable.h
+++ b/xpcom/ds/nsDataHashtable.h
@@ -58,16 +58,16 @@ public:
* @param aKey the key to retrieve and remove
* @return the found value, or Nothing if no entry was found with the
* given key.
*/
mozilla::Maybe<DataType> GetAndRemove(KeyType aKey)
{
mozilla::Maybe<DataType> value;
if (EntryType* ent = this->GetEntry(aKey)) {
- value.emplace(mozilla::Move(ent->mData));
+ value.emplace(std::move(ent->mData));
this->RemoveEntry(ent);
}
return value;
}
};
#endif // nsDataHashtable_h__
--- a/xpcom/ds/nsHashPropertyBag.cpp
+++ b/xpcom/ds/nsHashPropertyBag.cpp
@@ -261,36 +261,36 @@ NS_INTERFACE_MAP_END
* the nsIVariant values are main-thread only objects.
*/
class ProxyHashtableDestructor final : public mozilla::Runnable
{
public:
using HashtableType = nsInterfaceHashtable<nsStringHashKey, nsIVariant>;
explicit ProxyHashtableDestructor(HashtableType&& aTable)
: mozilla::Runnable("ProxyHashtableDestructor")
- , mPropertyHash(mozilla::Move(aTable))
+ , mPropertyHash(std::move(aTable))
{}
NS_IMETHODIMP
Run() override
{
MOZ_ASSERT(NS_IsMainThread());
- HashtableType table(mozilla::Move(mPropertyHash));
+ HashtableType table(std::move(mPropertyHash));
return NS_OK;
}
private:
HashtableType mPropertyHash;
};
nsHashPropertyBag::~nsHashPropertyBag()
{
if (!NS_IsMainThread()) {
RefPtr<ProxyHashtableDestructor> runnable =
- new ProxyHashtableDestructor(mozilla::Move(mPropertyHash));
+ new ProxyHashtableDestructor(std::move(mPropertyHash));
MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable));
}
}
/*
* nsHashPropertyBagCC implementation.
*/
--- a/xpcom/ds/nsInterfaceHashtable.h
+++ b/xpcom/ds/nsInterfaceHashtable.h
@@ -55,17 +55,17 @@ public:
Interface* GetWeak(KeyType aKey, bool* aFound = nullptr) const;
/**
* Allows inserting a value into the hashtable, moving its owning reference
* count into the hashtable, avoiding an AddRef.
*/
void Put(KeyType aKey, already_AddRefed<Interface>&& aData)
{
- if (!Put(aKey, mozilla::Move(aData), mozilla::fallible)) {
+ if (!Put(aKey, std::move(aData), mozilla::fallible)) {
NS_ABORT_OOM(this->mTable.EntrySize() * this->mTable.EntryCount());
}
}
MOZ_MUST_USE bool Put(KeyType aKey, already_AddRefed<Interface>&& aData,
const mozilla::fallible_t&);
using base_type::Put;
--- a/xpcom/ds/nsRefPtrHashtable.h
+++ b/xpcom/ds/nsRefPtrHashtable.h
@@ -158,17 +158,17 @@ nsRefPtrHashtable<KeyClass, PtrType>::Ge
return nullptr;
}
template<class KeyClass, class PtrType>
void
nsRefPtrHashtable<KeyClass, PtrType>::Put(KeyType aKey,
already_AddRefed<PtrType> aData)
{
- if (!Put(aKey, mozilla::Move(aData), mozilla::fallible)) {
+ if (!Put(aKey, std::move(aData), mozilla::fallible)) {
NS_ABORT_OOM(this->mTable.EntrySize() * this->mTable.EntryCount());
}
}
template<class KeyClass, class PtrType>
bool
nsRefPtrHashtable<KeyClass, PtrType>::Put(KeyType aKey,
already_AddRefed<PtrType> aData,
--- a/xpcom/ds/nsTArray.h
+++ b/xpcom/ds/nsTArray.h
@@ -654,17 +654,17 @@ struct nsTArray_CopyWithConstructors
return; // In practice, we don't do this.
}
// Figure out whether to copy back-to-front or front-to-back.
if (srcElemEnd > destElem && srcElemEnd < destElemEnd) {
while (destElemEnd != destElem) {
--destElemEnd;
--srcElemEnd;
- traits::Construct(destElemEnd, mozilla::Move(*srcElemEnd));
+ traits::Construct(destElemEnd, std::move(*srcElemEnd));
traits::Destruct(srcElemEnd);
}
} else {
MoveNonOverlappingRegion(aDest, aSrc, aCount, aElemSize);
}
}
static void MoveNonOverlappingRegion(void* aDest, void* aSrc, size_t aCount,
@@ -673,17 +673,17 @@ struct nsTArray_CopyWithConstructors
ElemType* destElem = static_cast<ElemType*>(aDest);
ElemType* srcElem = static_cast<ElemType*>(aSrc);
ElemType* destElemEnd = destElem + aCount;
#ifdef DEBUG
ElemType* srcElemEnd = srcElem + aCount;
MOZ_ASSERT(srcElemEnd <= destElem || srcElemEnd > destElemEnd);
#endif
while (destElem != destElemEnd) {
- traits::Construct(destElem, mozilla::Move(*srcElem));
+ traits::Construct(destElem, std::move(*srcElem));
traits::Destruct(srcElem);
++destElem;
++srcElem;
}
}
};
//
@@ -1656,17 +1656,17 @@ protected:
public:
template<class Item, class Allocator, typename ActualAlloc = Alloc>
/* MOZ_MUST_USE */
elem_type* AppendElements(nsTArray_Impl<Item, Allocator>&& aArray,
const mozilla::fallible_t&)
{
- return AppendElements<Item, Allocator>(mozilla::Move(aArray));
+ return AppendElements<Item, Allocator>(std::move(aArray));
}
// Append a new element, move constructing if possible.
protected:
template<class Item, typename ActualAlloc = Alloc>
elem_type* AppendElement(Item&& aItem);
public:
@@ -1733,17 +1733,17 @@ public:
// A variation on the RemoveElementAt that removes the last element.
void RemoveLastElement() { RemoveElementAt(Length() - 1); }
// Removes the last element of the array and returns a copy of it.
MOZ_MUST_USE
elem_type PopLastElement()
{
- elem_type elem = mozilla::Move(LastElement());
+ elem_type elem = std::move(LastElement());
RemoveLastElement();
return elem;
}
// This method performs index-based removals from an array without preserving
// the order of the array. This is useful if you are using the array as a
// set-like data structure.
//
@@ -2326,50 +2326,50 @@ class nsTArray : public nsTArray_Impl<E,
public:
typedef nsTArray_Impl<E, nsTArrayInfallibleAllocator> base_type;
typedef nsTArray<E> self_type;
typedef typename base_type::size_type size_type;
nsTArray() {}
explicit nsTArray(size_type aCapacity) : base_type(aCapacity) {}
explicit nsTArray(const nsTArray& aOther) : base_type(aOther) {}
- MOZ_IMPLICIT nsTArray(nsTArray&& aOther) : base_type(mozilla::Move(aOther)) {}
+ MOZ_IMPLICIT nsTArray(nsTArray&& aOther) : base_type(std::move(aOther)) {}
MOZ_IMPLICIT nsTArray(std::initializer_list<E> aIL) : base_type(aIL) {}
template<class Allocator>
explicit nsTArray(const nsTArray_Impl<E, Allocator>& aOther)
: base_type(aOther)
{
}
template<class Allocator>
MOZ_IMPLICIT nsTArray(nsTArray_Impl<E, Allocator>&& aOther)
- : base_type(mozilla::Move(aOther))
+ : base_type(std::move(aOther))
{
}
self_type& operator=(const self_type& aOther)
{
base_type::operator=(aOther);
return *this;
}
template<class Allocator>
self_type& operator=(const nsTArray_Impl<E, Allocator>& aOther)
{
base_type::operator=(aOther);
return *this;
}
self_type& operator=(self_type&& aOther)
{
- base_type::operator=(mozilla::Move(aOther));
+ base_type::operator=(std::move(aOther));
return *this;
}
template<class Allocator>
self_type& operator=(nsTArray_Impl<E, Allocator>&& aOther)
{
- base_type::operator=(mozilla::Move(aOther));
+ base_type::operator=(std::move(aOther));
return *this;
}
using base_type::AppendElement;
using base_type::AppendElements;
using base_type::EnsureLengthAtLeast;
using base_type::InsertElementAt;
using base_type::InsertElementsAt;
@@ -2389,51 +2389,51 @@ public:
typedef nsTArray_Impl<E, nsTArrayFallibleAllocator> base_type;
typedef FallibleTArray<E> self_type;
typedef typename base_type::size_type size_type;
FallibleTArray() {}
explicit FallibleTArray(size_type aCapacity) : base_type(aCapacity) {}
explicit FallibleTArray(const FallibleTArray<E>& aOther) : base_type(aOther) {}
FallibleTArray(FallibleTArray<E>&& aOther)
- : base_type(mozilla::Move(aOther))
+ : base_type(std::move(aOther))
{
}
template<class Allocator>
explicit FallibleTArray(const nsTArray_Impl<E, Allocator>& aOther)
: base_type(aOther)
{
}
template<class Allocator>
explicit FallibleTArray(nsTArray_Impl<E, Allocator>&& aOther)
- : base_type(mozilla::Move(aOther))
+ : base_type(std::move(aOther))
{
}
self_type& operator=(const self_type& aOther)
{
base_type::operator=(aOther);
return *this;
}
template<class Allocator>
self_type& operator=(const nsTArray_Impl<E, Allocator>& aOther)
{
base_type::operator=(aOther);
return *this;
}
self_type& operator=(self_type&& aOther)
{
- base_type::operator=(mozilla::Move(aOther));
+ base_type::operator=(std::move(aOther));
return *this;
}
template<class Allocator>
self_type& operator=(nsTArray_Impl<E, Allocator>&& aOther)
{
- base_type::operator=(mozilla::Move(aOther));
+ base_type::operator=(std::move(aOther));
return *this;
}
};
//
// AutoTArray<E, N> is like nsTArray<E>, but with N elements of inline storage.
// Storing more than N elements is fine, but it will cause a heap allocation.
//
--- a/xpcom/ds/nsTHashtable.h
+++ b/xpcom/ds/nsTHashtable.h
@@ -393,17 +393,17 @@ FixedSizeEntryMover(PLDHashTable*,
} // namespace mozilla
//
// template definitions
//
template<class EntryType>
nsTHashtable<EntryType>::nsTHashtable(nsTHashtable<EntryType>&& aOther)
- : mTable(mozilla::Move(aOther.mTable))
+ : mTable(std::move(aOther.mTable))
{
}
template<class EntryType>
nsTHashtable<EntryType>::~nsTHashtable()
{
}
@@ -447,17 +447,17 @@ template<class EntryType>
void
nsTHashtable<EntryType>::s_CopyEntry(PLDHashTable* aTable,
const PLDHashEntryHdr* aFrom,
PLDHashEntryHdr* aTo)
{
EntryType* fromEntry =
const_cast<EntryType*>(static_cast<const EntryType*>(aFrom));
- new (mozilla::KnownNotNull, aTo) EntryType(mozilla::Move(*fromEntry));
+ new (mozilla::KnownNotNull, aTo) EntryType(std::move(*fromEntry));
fromEntry->~EntryType();
}
template<class EntryType>
void
nsTHashtable<EntryType>::s_ClearEntry(PLDHashTable* aTable,
PLDHashEntryHdr* aEntry)
@@ -614,17 +614,17 @@ public:
}
class Iterator : public Base::Iterator
{
public:
typedef nsTHashtable::Base::Iterator Base;
explicit Iterator(nsTHashtable* aTable) : Base(aTable) {}
- Iterator(Iterator&& aOther) : Base(mozilla::Move(aOther)) {}
+ Iterator(Iterator&& aOther) : Base(std::move(aOther)) {}
~Iterator() = default;
EntryType* Get() const { return reinterpret_cast<EntryType*>(Base::Get()); }
private:
Iterator() = delete;
Iterator(const Iterator&) = delete;
Iterator& operator=(const Iterator&) = delete;
--- a/xpcom/io/NonBlockingAsyncInputStream.cpp
+++ b/xpcom/io/NonBlockingAsyncInputStream.cpp
@@ -55,17 +55,17 @@ NS_INTERFACE_MAP_BEGIN(NonBlockingAsyncI
NS_INTERFACE_MAP_END
/* static */ nsresult
NonBlockingAsyncInputStream::Create(already_AddRefed<nsIInputStream> aInputStream,
nsIAsyncInputStream** aResult)
{
MOZ_DIAGNOSTIC_ASSERT(aResult);
- nsCOMPtr<nsIInputStream> inputStream = Move(aInputStream);
+ nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream);
bool nonBlocking = false;
nsresult rv = inputStream->IsNonBlocking(&nonBlocking);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
MOZ_DIAGNOSTIC_ASSERT(nonBlocking);
@@ -79,17 +79,17 @@ NonBlockingAsyncInputStream::Create(alre
RefPtr<NonBlockingAsyncInputStream> stream =
new NonBlockingAsyncInputStream(inputStream.forget());
stream.forget(aResult);
return NS_OK;
}
NonBlockingAsyncInputStream::NonBlockingAsyncInputStream(already_AddRefed<nsIInputStream> aInputStream)
- : mInputStream(Move(aInputStream))
+ : mInputStream(std::move(aInputStream))
, mWeakCloneableInputStream(nullptr)
, mWeakIPCSerializableInputStream(nullptr)
, mWeakSeekableInputStream(nullptr)
, mLock("NonBlockingAsyncInputStream::mLock")
, mClosed(false)
{
MOZ_ASSERT(mInputStream);
@@ -137,18 +137,18 @@ NonBlockingAsyncInputStream::Close()
nsresult rv = mInputStream->Close();
if (NS_WARN_IF(NS_FAILED(rv))) {
mWaitClosureOnly.reset();
return rv;
}
// If we have a WaitClosureOnly runnable, it's time to use it.
if (mWaitClosureOnly.isSome()) {
- waitClosureOnlyRunnable = Move(mWaitClosureOnly->mRunnable);
- waitClosureOnlyEventTarget = Move(mWaitClosureOnly->mEventTarget);
+ waitClosureOnlyRunnable = std::move(mWaitClosureOnly->mRunnable);
+ waitClosureOnlyEventTarget = std::move(mWaitClosureOnly->mEventTarget);
mWaitClosureOnly.reset();
// Now we want to dispatch the asyncWaitCallback.
mAsyncWaitCallback = waitClosureOnlyRunnable;
}
}
@@ -363,17 +363,17 @@ NonBlockingAsyncInputStream::SetEOF()
NS_ENSURE_STATE(mWeakSeekableInputStream);
return NS_ERROR_NOT_IMPLEMENTED;
}
void
NonBlockingAsyncInputStream::RunAsyncWaitCallback(NonBlockingAsyncInputStream::AsyncWaitRunnable* aRunnable,
already_AddRefed<nsIInputStreamCallback> aCallback)
{
- nsCOMPtr<nsIInputStreamCallback> callback = Move(aCallback);
+ nsCOMPtr<nsIInputStreamCallback> callback = std::move(aCallback);
{
MutexAutoLock lock(mLock);
if (mAsyncWaitCallback != aRunnable) {
// The callback has been canceled in the meantime.
return;
}
--- a/xpcom/io/SlicedInputStream.cpp
+++ b/xpcom/io/SlicedInputStream.cpp
@@ -50,17 +50,17 @@ SlicedInputStream::SlicedInputStream(alr
, mStart(aStart)
, mLength(aLength)
, mCurPos(0)
, mClosed(false)
, mAsyncWaitFlags(0)
, mAsyncWaitRequestedCount(0)
, mMutex("SlicedInputStream::mMutex")
{
- nsCOMPtr<nsIInputStream> inputStream = mozilla::Move(aInputStream);
+ nsCOMPtr<nsIInputStream> inputStream = std::move(aInputStream);
SetSourceStream(inputStream.forget());
}
SlicedInputStream::SlicedInputStream()
: mWeakCloneableInputStream(nullptr)
, mWeakIPCSerializableInputStream(nullptr)
, mWeakSeekableInputStream(nullptr)
, mWeakAsyncInputStream(nullptr)
@@ -76,17 +76,17 @@ SlicedInputStream::SlicedInputStream()
SlicedInputStream::~SlicedInputStream()
{}
void
SlicedInputStream::SetSourceStream(already_AddRefed<nsIInputStream> aInputStream)
{
MOZ_ASSERT(!mInputStream);
- mInputStream = mozilla::Move(aInputStream);
+ mInputStream = std::move(aInputStream);
nsCOMPtr<nsICloneableInputStream> cloneableStream =
do_QueryInterface(mInputStream);
if (cloneableStream && SameCOMIdentity(mInputStream, cloneableStream)) {
mWeakCloneableInputStream = cloneableStream;
}
nsCOMPtr<nsIIPCSerializableInputStream> serializableStream =
--- a/xpcom/io/nsStreamUtils.cpp
+++ b/xpcom/io/nsStreamUtils.cpp
@@ -967,17 +967,17 @@ NS_CloneInputStream(nsIInputStream* aSou
return NS_OK;
}
nsresult
NS_MakeAsyncNonBlockingInputStream(already_AddRefed<nsIInputStream> aSource,
nsIAsyncInputStream** aAsyncInputStream)
{
- nsCOMPtr<nsIInputStream> source = Move(aSource);
+ nsCOMPtr<nsIInputStream> source = std::move(aSource);
if (NS_WARN_IF(!aAsyncInputStream)) {
return NS_ERROR_FAILURE;
}
bool nonBlocking = false;
nsresult rv = source->IsNonBlocking(&nonBlocking);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
--- a/xpcom/io/nsStringStream.cpp
+++ b/xpcom/io/nsStringStream.cpp
@@ -83,17 +83,17 @@ private:
nsDependentCSubstring mData;
uint32_t mOffset;
};
nsresult
nsStringInputStream::Init(nsCString&& aString)
{
- if (!mData.Assign(Move(aString), fallible)) {
+ if (!mData.Assign(std::move(aString), fallible)) {
return NS_ERROR_OUT_OF_MEMORY;
}
mOffset = 0;
return NS_OK;
}
// This class needs to support threadsafe refcounting since people often
@@ -462,17 +462,17 @@ NS_NewCStringInputStream(nsIInputStream*
nsresult
NS_NewCStringInputStream(nsIInputStream** aStreamResult,
nsCString&& aStringToRead)
{
MOZ_ASSERT(aStreamResult, "null out ptr");
RefPtr<nsStringInputStream> stream = new nsStringInputStream();
- nsresult rv = stream->Init(Move(aStringToRead));
+ nsresult rv = stream->Init(std::move(aStringToRead));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
stream.forget(aStreamResult);
return NS_OK;
}
--- a/xpcom/string/nsSubstring.cpp
+++ b/xpcom/string/nsSubstring.cpp
@@ -407,17 +407,17 @@ void Gecko_FinalizeCString(nsACString* a
void Gecko_AssignCString(nsACString* aThis, const nsACString* aOther)
{
aThis->Assign(*aOther);
}
void Gecko_TakeFromCString(nsACString* aThis, nsACString* aOther)
{
- aThis->Assign(mozilla::Move(*aOther));
+ aThis->Assign(std::move(*aOther));
}
void Gecko_AppendCString(nsACString* aThis, const nsACString* aOther)
{
aThis->Append(*aOther);
}
void Gecko_SetLengthCString(nsACString* aThis, uint32_t aLength)
@@ -427,17 +427,17 @@ void Gecko_SetLengthCString(nsACString*
bool Gecko_FallibleAssignCString(nsACString* aThis, const nsACString* aOther)
{
return aThis->Assign(*aOther, mozilla::fallible);
}
bool Gecko_FallibleTakeFromCString(nsACString* aThis, nsACString* aOther)
{
- return aThis->Assign(mozilla::Move(*aOther), mozilla::fallible);
+ return aThis->Assign(std::move(*aOther), mozilla::fallible);
}
bool Gecko_FallibleAppendCString(nsACString* aThis, const nsACString* aOther)
{
return aThis->Append(*aOther, mozilla::fallible);
}
bool Gecko_FallibleSetLengthCString(nsACString* aThis, uint32_t aLength)
@@ -462,17 +462,17 @@ void Gecko_FinalizeString(nsAString* aTh
void Gecko_AssignString(nsAString* aThis, const nsAString* aOther)
{
aThis->Assign(*aOther);
}
void Gecko_TakeFromString(nsAString* aThis, nsAString* aOther)
{
- aThis->Assign(mozilla::Move(*aOther));
+ aThis->Assign(std::move(*aOther));
}
void Gecko_AppendString(nsAString* aThis, const nsAString* aOther)
{
aThis->Append(*aOther);
}
void Gecko_SetLengthString(nsAString* aThis, uint32_t aLength)
@@ -482,17 +482,17 @@ void Gecko_SetLengthString(nsAString* aT
bool Gecko_FallibleAssignString(nsAString* aThis, const nsAString* aOther)
{
return aThis->Assign(*aOther, mozilla::fallible);
}
bool Gecko_FallibleTakeFromString(nsAString* aThis, nsAString* aOther)
{
- return aThis->Assign(mozilla::Move(*aOther), mozilla::fallible);
+ return aThis->Assign(std::move(*aOther), mozilla::fallible);
}
bool Gecko_FallibleAppendString(nsAString* aThis, const nsAString* aOther)
{
return aThis->Append(*aOther, mozilla::fallible);
}
bool Gecko_FallibleSetLengthString(nsAString* aThis, uint32_t aLength)
--- a/xpcom/string/nsTString.h
+++ b/xpcom/string/nsTString.h
@@ -95,17 +95,17 @@ public:
: substring_type(ClassFlags::NULL_TERMINATED)
{
this->Assign(aStr);
}
nsTString(self_type&& aStr)
: substring_type(ClassFlags::NULL_TERMINATED)
{
- this->Assign(mozilla::Move(aStr));
+ this->Assign(std::move(aStr));
}
MOZ_IMPLICIT nsTString(const substring_tuple_type& aTuple)
: substring_type(ClassFlags::NULL_TERMINATED)
{
this->Assign(aTuple);
}
@@ -115,17 +115,17 @@ public:
{
this->Assign(aReadable);
}
explicit
nsTString(substring_type&& aReadable)
: substring_type(ClassFlags::NULL_TERMINATED)
{
- this->Assign(mozilla::Move(aReadable));
+ this->Assign(std::move(aReadable));
}
// NOTE(nika): gcc 4.9 workaround. Remove when support is dropped.
explicit
nsTString(const literalstring_type& aReadable)
: substring_type(ClassFlags::NULL_TERMINATED)
{
this->Assign(aReadable);
@@ -145,17 +145,17 @@ public:
}
self_type& operator=(const self_type& aStr)
{
this->Assign(aStr);
return *this;
}
self_type& operator=(self_type&& aStr)
{
- this->Assign(mozilla::Move(aStr));
+ this->Assign(std::move(aStr));
return *this;
}
#if defined(MOZ_USE_CHAR16_WRAPPER)
template <typename Q = T, typename EnableIfChar16 = mozilla::Char16OnlyT<Q>>
self_type& operator=(const char16ptr_t aStr)
{
this->Assign(static_cast<const char16_t*>(aStr));
return *this;
@@ -163,17 +163,17 @@ public:
#endif
self_type& operator=(const substring_type& aStr)
{
this->Assign(aStr);
return *this;
}
self_type& operator=(substring_type&& aStr)
{
- this->Assign(mozilla::Move(aStr));
+ this->Assign(std::move(aStr));
return *this;
}
// NOTE(nika): gcc 4.9 workaround. Remove when support is dropped.
self_type& operator=(const literalstring_type& aStr)
{
this->Assign(aStr);
return *this;
}
@@ -618,31 +618,31 @@ public:
: self_type()
{
this->Assign(aStr);
}
nsTAutoStringN(self_type&& aStr)
: self_type()
{
- this->Assign(mozilla::Move(aStr));
+ this->Assign(std::move(aStr));
}
explicit
nsTAutoStringN(const substring_type& aStr)
: self_type()
{
this->Assign(aStr);
}
explicit
nsTAutoStringN(substring_type&& aStr)
: self_type()
{
- this->Assign(mozilla::Move(aStr));
+ this->Assign(std::move(aStr));
}
// NOTE(nika): gcc 4.9 workaround. Remove when support is dropped.
explicit
nsTAutoStringN(const literalstring_type& aStr)
: self_type()
{
this->Assign(aStr);
@@ -675,27 +675,27 @@ public:
#endif
self_type& operator=(const self_type& aStr)
{
this->Assign(aStr);
return *this;
}
self_type& operator=(self_type&& aStr)
{
- this->Assign(mozilla::Move(aStr));
+ this->Assign(std::move(aStr));
return *this;
}
self_type& operator=(const substring_type& aStr)
{
this->Assign(aStr);
return *this;
}
self_type& operator=(substring_type&& aStr)
{
- this->Assign(mozilla::Move(aStr));
+ this->Assign(std::move(aStr));
return *this;
}
// NOTE(nika): gcc 4.9 workaround. Remove when support is dropped.
self_type& operator=(const literalstring_type& aStr)
{
this->Assign(aStr);
return *this;
}
--- a/xpcom/string/nsTSubstring.cpp
+++ b/xpcom/string/nsTSubstring.cpp
@@ -485,17 +485,17 @@ nsTSubstring<T>::Assign(const self_type&
// else, treat this like an ordinary assignment.
return Assign(aStr.Data(), aStr.Length(), aFallible);
}
template <typename T>
void
nsTSubstring<T>::Assign(self_type&& aStr)
{
- if (!Assign(mozilla::Move(aStr), mozilla::fallible)) {
+ if (!Assign(std::move(aStr), mozilla::fallible)) {
AllocFailed(aStr.Length());
}
}
template <typename T>
bool
nsTSubstring<T>::Assign(self_type&& aStr, const fallible_t& aFallible)
{
--- a/xpcom/string/nsTSubstring.h
+++ b/xpcom/string/nsTSubstring.h
@@ -276,17 +276,17 @@ public:
#endif
self_type& operator=(const self_type& aStr)
{
Assign(aStr);
return *this;
}
self_type& operator=(self_type&& aStr)
{
- Assign(mozilla::Move(aStr));
+ Assign(std::move(aStr));
return *this;
}
// NOTE(nika): gcc 4.9 workaround. Remove when support is dropped.
self_type& operator=(const literalstring_type& aStr)
{
Assign(aStr);
return *this;
}
--- a/xpcom/tests/gtest/TestEventPriorities.cpp
+++ b/xpcom/tests/gtest/TestEventPriorities.cpp
@@ -16,17 +16,17 @@
using namespace mozilla;
class TestEvent final : public Runnable, nsIRunnablePriority
{
public:
explicit TestEvent(int* aCounter, std::function<void()>&& aCheck, uint32_t aPriority = nsIRunnablePriority::PRIORITY_NORMAL)
: Runnable("TestEvent")
, mCounter(aCounter)
- , mCheck(Move(aCheck))
+ , mCheck(std::move(aCheck))
, mPriority(aPriority)
{
}
NS_DECL_ISUPPORTS_INHERITED
NS_IMETHOD GetPriority(uint32_t* aPriority) override
{
--- a/xpcom/tests/gtest/TestMoveString.cpp
+++ b/xpcom/tests/gtest/TestMoveString.cpp
@@ -50,17 +50,17 @@ TEST(MoveString, SharedIntoOwned) {
SetAsOwned(out, OLD_VAL);
EXPECT_EQ(out.GetDataFlags(), Df::OWNED | Df::TERMINATED);
nsCString in;
in.Assign(NEW_VAL);
EXPECT_EQ(in.GetDataFlags(), Df::REFCOUNTED | Df::TERMINATED);
const char* data = in.get();
- out.Assign(mozilla::Move(in));
+ out.Assign(std::move(in));
ExpectTruncated(in);
ExpectNew(out);
EXPECT_EQ(out.GetDataFlags(), Df::REFCOUNTED | Df::TERMINATED);
EXPECT_EQ(out.get(), data);
}
TEST(MoveString, OwnedIntoOwned) {
@@ -68,17 +68,17 @@ TEST(MoveString, OwnedIntoOwned) {
SetAsOwned(out, OLD_VAL);
EXPECT_EQ(out.GetDataFlags(), Df::OWNED | Df::TERMINATED);
nsCString in;
SetAsOwned(in, NEW_VAL);
EXPECT_EQ(in.GetDataFlags(), Df::OWNED | Df::TERMINATED);
const char* data = in.get();
- out.Assign(mozilla::Move(in));
+ out.Assign(std::move(in));
ExpectTruncated(in);
ExpectNew(out);
EXPECT_EQ(out.GetDataFlags(), Df::OWNED | Df::TERMINATED);
EXPECT_EQ(out.get(), data);
}
TEST(MoveString, LiteralIntoOwned) {
@@ -86,17 +86,17 @@ TEST(MoveString, LiteralIntoOwned) {
SetAsOwned(out, OLD_VAL);
EXPECT_EQ(out.GetDataFlags(), Df::OWNED | Df::TERMINATED);
nsCString in;
in.AssignLiteral(NEW_VAL);
EXPECT_EQ(in.GetDataFlags(), Df::LITERAL | Df::TERMINATED);
const char* data = in.get();
- out.Assign(mozilla::Move(in));
+ out.Assign(std::move(in));
ExpectTruncated(in);
ExpectNew(out);
EXPECT_EQ(out.GetDataFlags(), Df::LITERAL | Df::TERMINATED);
EXPECT_EQ(out.get(), data);
}
TEST(MoveString, AutoIntoOwned) {
@@ -104,48 +104,48 @@ TEST(MoveString, AutoIntoOwned) {
SetAsOwned(out, OLD_VAL);
EXPECT_EQ(out.GetDataFlags(), Df::OWNED | Df::TERMINATED);
nsAutoCString in;
in.Assign(NEW_VAL);
EXPECT_EQ(in.GetDataFlags(), Df::INLINE | Df::TERMINATED);
const char* data = in.get();
- out.Assign(mozilla::Move(in));
+ out.Assign(std::move(in));
ExpectTruncated(in);
ExpectNew(out);
EXPECT_EQ(out.GetDataFlags(), Df::REFCOUNTED | Df::TERMINATED);
EXPECT_NE(out.get(), data);
}
TEST(MoveString, DepIntoOwned) {
nsCString out;
SetAsOwned(out, OLD_VAL);
EXPECT_EQ(out.GetDataFlags(), Df::OWNED | Df::TERMINATED);
nsDependentCSubstring in(NEW_VAL "garbage after", strlen(NEW_VAL));
EXPECT_EQ(in.GetDataFlags(), Df(0));
- out.Assign(mozilla::Move(in));
+ out.Assign(std::move(in));
ExpectTruncated(in);
ExpectNew(out);
EXPECT_EQ(out.GetDataFlags(), Df::REFCOUNTED | Df::TERMINATED);
}
TEST(MoveString, VoidIntoOwned) {
nsCString out;
SetAsOwned(out, OLD_VAL);
EXPECT_EQ(out.GetDataFlags(), Df::OWNED | Df::TERMINATED);
nsCString in = VoidCString();
EXPECT_EQ(in.GetDataFlags(), Df::VOIDED | Df::TERMINATED);
- out.Assign(mozilla::Move(in));
+ out.Assign(std::move(in));
ExpectTruncated(in);
EXPECT_EQ(out.Length(), 0u);
EXPECT_STREQ(out.get(), "");
EXPECT_EQ(out.GetDataFlags(), Df::VOIDED | Df::TERMINATED);
}
TEST(MoveString, SharedIntoAuto) {
@@ -153,17 +153,17 @@ TEST(MoveString, SharedIntoAuto) {
out.Assign(OLD_VAL);
EXPECT_EQ(out.GetDataFlags(), Df::INLINE | Df::TERMINATED);
nsCString in;
in.Assign(NEW_VAL);
EXPECT_EQ(in.GetDataFlags(), Df::REFCOUNTED | Df::TERMINATED);
const char* data = in.get();
- out.Assign(mozilla::Move(in));
+ out.Assign(std::move(in));
ExpectTruncated(in);
ExpectNew(out);
EXPECT_EQ(out.GetDataFlags(), Df::REFCOUNTED | Df::TERMINATED);
EXPECT_EQ(out.get(), data);
}
TEST(MoveString, OwnedIntoAuto) {
@@ -171,17 +171,17 @@ TEST(MoveString, OwnedIntoAuto) {
out.Assign(OLD_VAL);
EXPECT_EQ(out.GetDataFlags(), Df::INLINE | Df::TERMINATED);
nsCString in;
SetAsOwned(in, NEW_VAL);
EXPECT_EQ(in.GetDataFlags(), Df::OWNED | Df::TERMINATED);
const char* data = in.get();
- out.Assign(mozilla::Move(in));
+ out.Assign(std::move(in));
ExpectTruncated(in);
ExpectNew(out);
EXPECT_EQ(out.GetDataFlags(), Df::OWNED | Df::TERMINATED);
EXPECT_EQ(out.get(), data);
}
TEST(MoveString, LiteralIntoAuto) {
@@ -189,17 +189,17 @@ TEST(MoveString, LiteralIntoAuto) {
out.Assign(OLD_VAL);
EXPECT_EQ(out.GetDataFlags(), Df::INLINE | Df::TERMINATED);
nsCString in;
in.AssignLiteral(NEW_VAL);
EXPECT_EQ(in.GetDataFlags(), Df::LITERAL | Df::TERMINATED);
const char* data = in.get();
- out.Assign(mozilla::Move(in));
+ out.Assign(std::move(in));
ExpectTruncated(in);
ExpectNew(out);
EXPECT_EQ(out.GetDataFlags(), Df::LITERAL | Df::TERMINATED);
EXPECT_EQ(out.get(), data);
}
TEST(MoveString, AutoIntoAuto) {
@@ -207,48 +207,48 @@ TEST(MoveString, AutoIntoAuto) {
out.Assign(OLD_VAL);
EXPECT_EQ(out.GetDataFlags(), Df::INLINE | Df::TERMINATED);
nsAutoCString in;
in.Assign(NEW_VAL);
EXPECT_EQ(in.GetDataFlags(), Df::INLINE | Df::TERMINATED);
const char* data = in.get();
- out.Assign(mozilla::Move(in));
+ out.Assign(std::move(in));
ExpectTruncated(in);
ExpectNew(out);
EXPECT_EQ(out.GetDataFlags(), Df::INLINE | Df::TERMINATED);
EXPECT_NE(out.get(), data);
}
TEST(MoveString, DepIntoAuto) {
nsAutoCString out;
out.Assign(OLD_VAL);
EXPECT_EQ(out.GetDataFlags(), Df::INLINE | Df::TERMINATED);
nsDependentCSubstring in(NEW_VAL "garbage after", strlen(NEW_VAL));
EXPECT_EQ(in.GetDataFlags(), Df(0));
- out.Assign(mozilla::Move(in));
+ out.Assign(std::move(in));
ExpectTruncated(in);
ExpectNew(out);
EXPECT_EQ(out.GetDataFlags(), Df::INLINE | Df::TERMINATED);
}
TEST(MoveString, VoidIntoAuto) {
nsAutoCString out;
out.Assign(OLD_VAL);
EXPECT_EQ(out.GetDataFlags(), Df::INLINE | Df::TERMINATED);
nsCString in = VoidCString();
EXPECT_EQ(in.GetDataFlags(), Df::VOIDED | Df::TERMINATED);
- out.Assign(mozilla::Move(in));
+ out.Assign(std::move(in));
ExpectTruncated(in);
EXPECT_EQ(out.Length(), 0u);
EXPECT_STREQ(out.get(), "");
EXPECT_EQ(out.GetDataFlags(), Df::VOIDED | Df::TERMINATED);
}
#undef NEW_VAL
--- a/xpcom/tests/gtest/TestMozPromise.cpp
+++ b/xpcom/tests/gtest/TestMozPromise.cpp
@@ -308,18 +308,18 @@ TEST(MozPromise, ResolveOrRejectValue)
EXPECT_FALSE(val.IsReject());
val.SetResolve(MakeUnique<int>(87));
EXPECT_FALSE(val.IsNothing());
EXPECT_TRUE(val.IsResolve());
EXPECT_FALSE(val.IsReject());
EXPECT_EQ(87, *val.ResolveValue());
- // IsResolve() should remain true after Move().
- UniquePtr<int> i = Move(val.ResolveValue());
+ // IsResolve() should remain true after std::move().
+ UniquePtr<int> i = std::move(val.ResolveValue());
EXPECT_EQ(87, *i);
EXPECT_TRUE(val.IsResolve());
EXPECT_EQ(val.ResolveValue().get(), nullptr);
}
TEST(MozPromise, MoveOnlyType)
{
using MyPromise = MozPromise<UniquePtr<int>, bool, true>;
@@ -338,18 +338,18 @@ TEST(MozPromise, MoveOnlyType)
MyPromise::CreateAndResolve(MakeUnique<int>(87), __func__)
->Then(queue, __func__,
[queue](RRValue&& aVal) {
EXPECT_FALSE(aVal.IsNothing());
EXPECT_TRUE(aVal.IsResolve());
EXPECT_FALSE(aVal.IsReject());
EXPECT_EQ(87, *aVal.ResolveValue());
- // Move() shouldn't change the resolve/reject state of aVal.
- RRValue val = Move(aVal);
+ // std::move() shouldn't change the resolve/reject state of aVal.
+ RRValue val = std::move(aVal);
EXPECT_TRUE(aVal.IsResolve());
EXPECT_EQ(nullptr, aVal.ResolveValue().get());
EXPECT_EQ(87, *val.ResolveValue());
queue->BeginShutdown();
});
}
--- a/xpcom/tests/gtest/TestPLDHash.cpp
+++ b/xpcom/tests/gtest/TestPLDHash.cpp
@@ -192,38 +192,38 @@ static const PLDHashTableOps trivialOps
TEST(PLDHashTableTest, MoveSemantics)
{
PLDHashTable t1(&trivialOps, sizeof(PLDHashEntryStub));
t1.Add((const void*)88);
PLDHashTable t2(&trivialOps, sizeof(PLDHashEntryStub));
t2.Add((const void*)99);
- t1 = mozilla::Move(t1); // self-move
+ t1 = std::move(t1); // self-move
- t1 = mozilla::Move(t2); // empty overwritten with empty
+ t1 = std::move(t2); // empty overwritten with empty
PLDHashTable t3(&trivialOps, sizeof(PLDHashEntryStub));
PLDHashTable t4(&trivialOps, sizeof(PLDHashEntryStub));
t3.Add((const void*)88);
- t3 = mozilla::Move(t4); // non-empty overwritten with empty
+ t3 = std::move(t4); // non-empty overwritten with empty
PLDHashTable t5(&trivialOps, sizeof(PLDHashEntryStub));
PLDHashTable t6(&trivialOps, sizeof(PLDHashEntryStub));
t6.Add((const void*)88);
- t5 = mozilla::Move(t6); // empty overwritten with non-empty
+ t5 = std::move(t6); // empty overwritten with non-empty
PLDHashTable t7(&trivialOps, sizeof(PLDHashEntryStub));
- PLDHashTable t8(mozilla::Move(t7)); // new table constructed with uninited
+ PLDHashTable t8(std::move(t7)); // new table constructed with uninited
PLDHashTable t9(&trivialOps, sizeof(PLDHashEntryStub));
t9.Add((const void*)88);
- PLDHashTable t10(mozilla::Move(t9)); // new table constructed with inited
+ PLDHashTable t10(std::move(t9)); // new table constructed with inited
}
TEST(PLDHashTableTest, Clear)
{
PLDHashTable t1(&trivialOps, sizeof(PLDHashEntryStub));
t1.Clear();
ASSERT_EQ(t1.EntryCount(), 0u);
@@ -254,17 +254,17 @@ TEST(PLDHashTableTest, Iterator)
{
PLDHashTable t(&trivialOps, sizeof(PLDHashEntryStub));
// Explicitly test the move constructor. We do this because, due to copy
// elision, compilers might optimize away move constructor calls for normal
// iterator use.
{
PLDHashTable::Iterator iter1(&t);
- PLDHashTable::Iterator iter2(mozilla::Move(iter1));
+ PLDHashTable::Iterator iter2(std::move(iter1));
}
// Iterate through the empty table.
for (PLDHashTable::Iterator iter(&t); !iter.Done(); iter.Next()) {
(void) iter.Get();
ASSERT_TRUE(false); // shouldn't hit this
}
--- a/xpcom/tests/gtest/TestStrings.cpp
+++ b/xpcom/tests/gtest/TestStrings.cpp
@@ -446,17 +446,17 @@ TEST_F(Strings, DependentStrings)
// Both strings should be pointing to the original buffer.
EXPECT_EQ(data, tmp.Data());
EXPECT_EQ(data, foo.Data());
}
{
// Test move ctor.
nsDependentCString tmp("foo");
auto data = tmp.Data();
- nsDependentCString foo(mozilla::Move(tmp));
+ nsDependentCString foo(std::move(tmp));
// Neither string should be using a shared buffer.
EXPECT_FALSE(tmp.GetDataFlags() & DataFlags::REFCOUNTED);
EXPECT_FALSE(foo.GetDataFlags() & DataFlags::REFCOUNTED);
// First string should be reset, the second should be pointing to the
// original buffer.
EXPECT_NE(data, tmp.Data());
EXPECT_EQ(data, foo.Data());
EXPECT_TRUE(tmp.IsEmpty());
--- a/xpcom/tests/gtest/TestTArray.cpp
+++ b/xpcom/tests/gtest/TestTArray.cpp
@@ -94,22 +94,22 @@ const nsTArray<int>& FakeHugeArray()
}
#endif
TEST(TArray, AppendElementsRvalue)
{
nsTArray<int> array;
nsTArray<int> temp(DummyArray());
- array.AppendElements(Move(temp));
+ array.AppendElements(std::move(temp));
ASSERT_EQ(DummyArray(), array);
ASSERT_TRUE(temp.IsEmpty());
temp = DummyArray();
- array.AppendElements(Move(temp));
+ array.AppendElements(std::move(temp));
nsTArray<int> expected;
expected.AppendElements(DummyArray());
expected.AppendElements(DummyArray());
ASSERT_EQ(expected, array);
ASSERT_TRUE(temp.IsEmpty());
}
TEST(TArray, Assign)
@@ -121,29 +121,29 @@ TEST(TArray, Assign)
ASSERT_TRUE(array.Assign(DummyArray(), fallible));
ASSERT_EQ(DummyArray(), array);
#ifdef DEBUG
ASSERT_FALSE(array.Assign(FakeHugeArray(), fallible));
#endif
nsTArray<int> array2;
- array2.Assign(Move(array));
+ array2.Assign(std::move(array));
ASSERT_TRUE(array.IsEmpty());
ASSERT_EQ(DummyArray(), array2);
}
TEST(TArray, AssignmentOperatorSelfAssignment)
{
nsTArray<int> array;
array = DummyArray();
array = *&array;
ASSERT_EQ(DummyArray(), array);
- array = Move(array);
+ array = std::move(array);
ASSERT_EQ(DummyArray(), array);
}
TEST(TArray, CopyOverlappingForwards)
{
const size_t rangeLength = 8;
const size_t initialLength = 2 * rangeLength;
uint32_t destructionCounters[initialLength];
--- a/xpcom/tests/gtest/TestTArray2.cpp
+++ b/xpcom/tests/gtest/TestTArray2.cpp
@@ -309,40 +309,40 @@ TEST(TArray, test_move_array) {
const nsTArray<Countable>& constRefCountableArray = countableArray;
ASSERT_EQ(Countable::Count(), 8);
nsTArray<Countable> copyCountableArray(constRefCountableArray);
ASSERT_EQ(Countable::Count(), 12);
- nsTArray<Countable>&& moveRefCountableArray = Move(countableArray);
+ nsTArray<Countable>&& moveRefCountableArray = std::move(countableArray);
moveRefCountableArray.Length(); // Make compilers happy.
ASSERT_EQ(Countable::Count(), 12);
- nsTArray<Countable> movedCountableArray(Move(countableArray));
+ nsTArray<Countable> movedCountableArray(std::move(countableArray));
ASSERT_EQ(Countable::Count(), 12);
// Test ctor
- FallibleTArray<Countable> differentAllocatorCountableArray(Move(copyCountableArray));
+ FallibleTArray<Countable> differentAllocatorCountableArray(std::move(copyCountableArray));
// operator=
- copyCountableArray = Move(differentAllocatorCountableArray);
- differentAllocatorCountableArray = Move(copyCountableArray);
+ copyCountableArray = std::move(differentAllocatorCountableArray);
+ differentAllocatorCountableArray = std::move(copyCountableArray);
// And the other ctor
- nsTArray<Countable> copyCountableArray2(Move(differentAllocatorCountableArray));
+ nsTArray<Countable> copyCountableArray2(std::move(differentAllocatorCountableArray));
// with auto
- AutoTArray<Countable, 3> autoCountableArray(Move(copyCountableArray2));
+ AutoTArray<Countable, 3> autoCountableArray(std::move(copyCountableArray2));
// operator=
- copyCountableArray2 = Move(autoCountableArray);
+ copyCountableArray2 = std::move(autoCountableArray);
// Mix with FallibleTArray
- FallibleTArray<Countable> differentAllocatorCountableArray2(Move(copyCountableArray2));
- AutoTArray<Countable, 4> autoCountableArray2(Move(differentAllocatorCountableArray2));
- differentAllocatorCountableArray2 = Move(autoCountableArray2);
+ FallibleTArray<Countable> differentAllocatorCountableArray2(std::move(copyCountableArray2));
+ AutoTArray<Countable, 4> autoCountableArray2(std::move(differentAllocatorCountableArray2));
+ differentAllocatorCountableArray2 = std::move(autoCountableArray2);
ASSERT_EQ(Countable::Count(), 12);
nsTArray<Moveable> moveableArray;
for (i = 0; i < 4; ++i) {
ASSERT_TRUE(moveableArray.AppendElement(Moveable()));
}
@@ -351,40 +351,40 @@ TEST(TArray, test_move_array) {
const nsTArray<Moveable>& constRefMoveableArray = moveableArray;
ASSERT_EQ(Moveable::Count(), 4);
nsTArray<Moveable> copyMoveableArray(constRefMoveableArray);
ASSERT_EQ(Moveable::Count(), 8);
- nsTArray<Moveable>&& moveRefMoveableArray = Move(moveableArray);
+ nsTArray<Moveable>&& moveRefMoveableArray = std::move(moveableArray);
moveRefMoveableArray.Length(); // Make compilers happy.
ASSERT_EQ(Moveable::Count(), 8);
- nsTArray<Moveable> movedMoveableArray(Move(moveableArray));
+ nsTArray<Moveable> movedMoveableArray(std::move(moveableArray));
ASSERT_EQ(Moveable::Count(), 8);
// Test ctor
- FallibleTArray<Moveable> differentAllocatorMoveableArray(Move(copyMoveableArray));
+ FallibleTArray<Moveable> differentAllocatorMoveableArray(std::move(copyMoveableArray));
// operator=
- copyMoveableArray = Move(differentAllocatorMoveableArray);
- differentAllocatorMoveableArray = Move(copyMoveableArray);
+ copyMoveableArray = std::move(differentAllocatorMoveableArray);
+ differentAllocatorMoveableArray = std::move(copyMoveableArray);
// And the other ctor
- nsTArray<Moveable> copyMoveableArray2(Move(differentAllocatorMoveableArray));
+ nsTArray<Moveable> copyMoveableArray2(std::move(differentAllocatorMoveableArray));
// with auto
- AutoTArray<Moveable, 3> autoMoveableArray(Move(copyMoveableArray2));
+ AutoTArray<Moveable, 3> autoMoveableArray(std::move(copyMoveableArray2));
// operator=
- copyMoveableArray2 = Move(autoMoveableArray);
+ copyMoveableArray2 = std::move(autoMoveableArray);
// Mix with FallibleTArray
- FallibleTArray<Moveable> differentAllocatorMoveableArray2(Move(copyMoveableArray2));
- AutoTArray<Moveable, 4> autoMoveableArray2(Move(differentAllocatorMoveableArray2));
- differentAllocatorMoveableArray2 = Move(autoMoveableArray2);
+ FallibleTArray<Moveable> differentAllocatorMoveableArray2(std::move(copyMoveableArray2));
+ AutoTArray<Moveable, 4> autoMoveableArray2(std::move(differentAllocatorMoveableArray2));
+ differentAllocatorMoveableArray2 = std::move(autoMoveableArray2);
ASSERT_EQ(Moveable::Count(), 8);
}
//----
TEST(TArray, test_string_array) {
nsTArray<nsCString> strArray;
--- a/xpcom/tests/gtest/TestThreadUtils.cpp
+++ b/xpcom/tests/gtest/TestThreadUtils.cpp
@@ -235,18 +235,18 @@ static void TestNewRunnableFunction(bool
{
int moveCounter = 0;
{
nsCOMPtr<nsIRunnable> trackedRunnable;
{
TestMove tracker(&moveCounter);
trackedRunnable =
aNamed
- ? NS_NewRunnableFunction("unused", Move(tracker))
- : NS_NewRunnableFunction("TestNewRunnableFunction", Move(tracker));
+ ? NS_NewRunnableFunction("unused", std::move(tracker))
+ : NS_NewRunnableFunction("TestNewRunnableFunction", std::move(tracker));
}
trackedRunnable->Run();
}
Expect("NS_NewRunnableFunction with movable-only function, moves",
moveCounter, 1);
}
{
int moveCounter = 0;
@@ -269,18 +269,18 @@ static void TestNewRunnableFunction(bool
int copyCounter = 0;
int moveCounter = 0;
{
nsCOMPtr<nsIRunnable> trackedRunnable;
{
TestCopyMove tracker(©Counter, &moveCounter);
trackedRunnable =
aNamed
- ? NS_NewRunnableFunction("unused", Move(tracker))
- : NS_NewRunnableFunction("TestNewRunnableFunction", Move(tracker));
+ ? NS_NewRunnableFunction("unused", std::move(tracker))
+ : NS_NewRunnableFunction("TestNewRunnableFunction", std::move(tracker));
}
trackedRunnable->Run();
}
Expect("NS_NewRunnableFunction with copyable&movable function, copies",
copyCounter, 0);
Expect("NS_NewRunnableFunction with copyable&movable function, moves",
moveCounter, 1);
}
@@ -1005,17 +1005,17 @@ public:
void TestByConstLRef(const Spy& s)
{
if (gDebug) { printf("TestByConstLRef(Spy[%d@%p]&)\n", s.mID, &s); }
mSpy = s;
};
void TestByRRef(Spy&& s)
{
if (gDebug) { printf("TestByRRef(Spy[%d@%p]&&)\n", s.mID, &s); }
- mSpy = mozilla::Move(s);
+ mSpy = std::move(s);
};
void TestByLRef(Spy& s)
{
if (gDebug) { printf("TestByLRef(Spy[%d@%p]&)\n", s.mID, &s); }
mSpy = s;
mSpyPtr = &s;
};
void TestByPointer(Spy* p)
@@ -1385,17 +1385,17 @@ TEST(ThreadUtils, main)
int&&>::value,
"ParameterStorage<int&&>::Type::passed_type should be int&&");
{
int i = 14;
r1 =
NewRunnableMethod<int&&>("TestThreadUtils::ThreadUtilsObject::Test1rri",
rpt,
&ThreadUtilsObject::Test1rri,
- mozilla::Move(i));
+ std::move(i));
}
r1->Run();
EXPECT_EQ(count += 2, rpt->mCount);
EXPECT_EQ(14, rpt->mA0);
// Null unique pointer, by semi-implicit store&move with "T&&" syntax.
static_assert(mozilla::IsSame< ::detail::ParameterStorage<mozilla::UniquePtr<int>&&>::Type,
StoreCopyPassByRRef<mozilla::UniquePtr<int>>>::value,
@@ -1410,17 +1410,17 @@ TEST(ThreadUtils, main)
mozilla::UniquePtr<int>&&>::value,
"ParameterStorage<UniquePtr<int>&&>::Type::passed_type should be UniquePtr<int>&&");
{
mozilla::UniquePtr<int> upi;
r1 = NewRunnableMethod<mozilla::UniquePtr<int>&&>(
"TestThreadUtils::ThreadUtilsObject::Test1upi",
rpt,
&ThreadUtilsObject::Test1upi,
- mozilla::Move(upi));
+ std::move(upi));
}
r1->Run();
EXPECT_EQ(count += 2, rpt->mCount);
EXPECT_EQ(-1, rpt->mA0);
rpt->mA0 = 0;
// Null unique pointer, by explicit store&move with "StoreCopyPassByRRef<T>" syntax.
static_assert(mozilla::IsSame< ::detail::ParameterStorage<StoreCopyPassByRRef<mozilla::UniquePtr<int>>>::Type::stored_type,
@@ -1436,42 +1436,42 @@ TEST(ThreadUtils, main)
mozilla::UniquePtr<int>&&>::value,
"ParameterStorage<StoreCopyPassByRRef<UniquePtr<int>>>::Type::passed_type should be UniquePtr<int>&&");
{
mozilla::UniquePtr<int> upi;
r1 = NewRunnableMethod<StoreCopyPassByRRef<mozilla::UniquePtr<int>>>(
"TestThreadUtils::ThreadUtilsObject::Test1upi",
rpt,
&ThreadUtilsObject::Test1upi,
- mozilla::Move(upi));
+ std::move(upi));
}
r1->Run();
EXPECT_EQ(count += 2, rpt->mCount);
EXPECT_EQ(-1, rpt->mA0);
// Unique pointer as xvalue.
{
mozilla::UniquePtr<int> upi = mozilla::MakeUnique<int>(1);
r1 = NewRunnableMethod<mozilla::UniquePtr<int>&&>(
"TestThreadUtils::ThreadUtilsObject::Test1upi",
rpt,
&ThreadUtilsObject::Test1upi,
- mozilla::Move(upi));
+ std::move(upi));
}
r1->Run();
EXPECT_EQ(count += 2, rpt->mCount);
EXPECT_EQ(1, rpt->mA0);
{
mozilla::UniquePtr<int> upi = mozilla::MakeUnique<int>(1);
r1 = NewRunnableMethod<StoreCopyPassByRRef<mozilla::UniquePtr<int>>>(
"TestThreadUtils::ThreadUtilsObject::Test1upi",
rpt,
&ThreadUtilsObject::Test1upi,
- mozilla::Move(upi));
+ std::move(upi));
}
r1->Run();
EXPECT_EQ(count += 2, rpt->mCount);
EXPECT_EQ(1, rpt->mA0);
// Unique pointer as prvalue.
r1 = NewRunnableMethod<mozilla::UniquePtr<int>&&>(
"TestThreadUtils::ThreadUtilsObject::Test1upi",
@@ -1567,17 +1567,17 @@ TEST(ThreadUtils, main)
Spy s(12);
EXPECT_EQ(1, gConstructions);
EXPECT_EQ(1, gAlive);
Spy::ClearActions();
r4 = NewRunnableMethod<StoreCopyPassByValue<Spy>>(
"TestThreadUtils::ThreadUtilsObject::TestByValue",
rpt,
&ThreadUtilsObject::TestByValue,
- mozilla::Move(s));
+ std::move(s));
EXPECT_LE(1, gMoveConstructions);
EXPECT_EQ(1, gAlive);
EXPECT_EQ(1, gZombies);
Spy::ClearActions();
}
EXPECT_EQ(1, gDestructions);
EXPECT_EQ(1, gAlive);
EXPECT_EQ(0, gZombies);
--- a/xpcom/threads/AbstractThread.cpp
+++ b/xpcom/threads/AbstractThread.cpp
@@ -46,20 +46,20 @@ public:
MOZ_ASSERT_IF(aRequireTailDispatch, NS_IsMainThread() && aTarget->IsOnCurrentThread());
}
virtual nsresult Dispatch(already_AddRefed<nsIRunnable> aRunnable,
DispatchReason aReason = NormalDispatch) override
{
AbstractThread* currentThread;
if (aReason != TailDispatch && (currentThread = GetCurrent()) && RequiresTailDispatch(currentThread)) {
- return currentThread->TailDispatcher().AddTask(this, Move(aRunnable));
+ return currentThread->TailDispatcher().AddTask(this, std::move(aRunnable));
}
- RefPtr<nsIRunnable> runner(new Runner(this, Move(aRunnable), false /* already drained by TaskGroupRunnable */));
+ RefPtr<nsIRunnable> runner(new Runner(this, std::move(aRunnable), false /* already drained by TaskGroupRunnable */));
return mTarget->Dispatch(runner.forget(), NS_DISPATCH_NORMAL);
}
// Prevent a GCC warning about the other overload of Dispatch being hidden.
using AbstractThread::Dispatch;
virtual bool IsCurrentThreadIn() override
{
@@ -102,17 +102,17 @@ private:
nsCOMPtr<nsIThread> mRunningThread;
RefPtr<nsIEventTarget> mTarget;
Maybe<AutoTaskDispatcher> mTailDispatcher;
virtual already_AddRefed<nsIRunnable>
CreateDirectTaskDrainer(already_AddRefed<nsIRunnable> aRunnable) override
{
RefPtr<Runner> runner =
- new Runner(this, Move(aRunnable), /* aDrainDirectTasks */ true);
+ new Runner(this, std::move(aRunnable), /* aDrainDirectTasks */ true);
return runner.forget();
}
class Runner : public CancelableRunnable {
class MOZ_STACK_CLASS AutoTaskGuard final {
public:
explicit AutoTaskGuard(EventTargetWrapper* aThread)
: mLastCurrentThread(nullptr)
@@ -216,17 +216,17 @@ AbstractThread::DispatchFromScript(nsIRu
{
nsCOMPtr<nsIRunnable> event(aEvent);
return Dispatch(event.forget(), aFlags);
}
NS_IMETHODIMP
AbstractThread::Dispatch(already_AddRefed<nsIRunnable> aEvent, uint32_t aFlags)
{
- return Dispatch(Move(aEvent), NormalDispatch);
+ return Dispatch(std::move(aEvent), NormalDispatch);
}
NS_IMETHODIMP
AbstractThread::DelayedDispatch(already_AddRefed<nsIRunnable> aEvent,
uint32_t aDelayMs)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
@@ -295,23 +295,23 @@ AbstractThread::InitMainThread()
if (!sCurrentThreadTLS.init()) {
MOZ_CRASH();
}
}
void
AbstractThread::DispatchStateChange(already_AddRefed<nsIRunnable> aRunnable)
{
- GetCurrent()->TailDispatcher().AddStateChangeTask(this, Move(aRunnable));
+ GetCurrent()->TailDispatcher().AddStateChangeTask(this, std::move(aRunnable));
}
/* static */ void
AbstractThread::DispatchDirectTask(already_AddRefed<nsIRunnable> aRunnable)
{
- GetCurrent()->TailDispatcher().AddDirectTask(Move(aRunnable));
+ GetCurrent()->TailDispatcher().AddDirectTask(std::move(aRunnable));
}
/* static */
already_AddRefed<AbstractThread>
AbstractThread::CreateXPCOMThreadWrapper(nsIThread* aThread, bool aRequireTailDispatch)
{
RefPtr<EventTargetWrapper> wrapper = new EventTargetWrapper(aThread, aRequireTailDispatch);
--- a/xpcom/threads/EventQueue.cpp
+++ b/xpcom/threads/EventQueue.cpp
@@ -14,17 +14,17 @@ EventQueue::EventQueue(EventPriority aPr
}
void
EventQueue::PutEvent(already_AddRefed<nsIRunnable>&& aEvent,
EventPriority aPriority,
const MutexAutoLock& aProofOfLock)
{
nsCOMPtr<nsIRunnable> event(aEvent);
- mQueue.Push(Move(event));
+ mQueue.Push(std::move(event));
}
already_AddRefed<nsIRunnable>
EventQueue::GetEvent(EventPriority* aPriority,
const MutexAutoLock& aProofOfLock)
{
if (mQueue.IsEmpty()) {
return nullptr;
--- a/xpcom/threads/HangMonitor.cpp
+++ b/xpcom/threads/HangMonitor.cpp
@@ -249,17 +249,17 @@ ThreadMain(void*)
}
}
#endif
} else {
#ifdef REPORT_CHROME_HANGS
if (waitCount >= 2) {
uint32_t hangDuration = PR_IntervalToSeconds(now - lastTimestamp);
Telemetry::RecordChromeHang(hangDuration, stack, systemUptime,
- firefoxUptime, Move(annotations));
+ firefoxUptime, std::move(annotations));
stack.Clear();
}
#endif
lastTimestamp = timestamp;
waitCount = 0;
}
TimeDuration timeout;
--- a/xpcom/threads/MainThreadQueue.h
+++ b/xpcom/threads/MainThreadQueue.h
@@ -26,17 +26,17 @@ CreateMainThread(nsIIdlePeriod* aIdlePer
MakeUnique<InnerQueueT>(EventPriority::High),
MakeUnique<InnerQueueT>(EventPriority::Input),
MakeUnique<InnerQueueT>(EventPriority::Normal),
MakeUnique<InnerQueueT>(EventPriority::Idle),
do_AddRef(aIdlePeriod));
MainThreadQueueT* prioritized = queue.get();
- RefPtr<SynchronizedQueueT> synchronizedQueue = new SynchronizedQueueT(Move(queue));
+ RefPtr<SynchronizedQueueT> synchronizedQueue = new SynchronizedQueueT(std::move(queue));
prioritized->SetMutexRef(synchronizedQueue->MutexRef());
// Setup "main" thread
RefPtr<nsThread> mainThread = new nsThread(WrapNotNull(synchronizedQueue), nsThread::MAIN_THREAD, 0);
#ifndef RELEASE_OR_BETA
prioritized->SetNextIdleDeadlineRef(mainThread->NextIdleDeadlineRef());
--- a/xpcom/threads/MozPromise.h
+++ b/xpcom/threads/MozPromise.h
@@ -293,38 +293,38 @@ private:
void Resolve(size_t aIndex, ResolveValueType&& aResolveValue)
{
if (!mPromise) {
// Already rejected.
return;
}
- mResolveValues[aIndex].emplace(Move(aResolveValue));
+ mResolveValues[aIndex].emplace(std::move(aResolveValue));
if (--mOutstandingPromises == 0) {
nsTArray<ResolveValueType> resolveValues;
resolveValues.SetCapacity(mResolveValues.Length());
for (auto&& resolveValue : mResolveValues) {
- resolveValues.AppendElement(Move(resolveValue.ref()));
+ resolveValues.AppendElement(std::move(resolveValue.ref()));
}
- mPromise->Resolve(Move(resolveValues), __func__);
+ mPromise->Resolve(std::move(resolveValues), __func__);
mPromise = nullptr;
mResolveValues.Clear();
}
}
void Reject(RejectValueType&& aRejectValue)
{
if (!mPromise) {
// Already rejected.
return;
}
- mPromise->Reject(Move(aRejectValue), __func__);
+ mPromise->Reject(std::move(aRejectValue), __func__);
mPromise = nullptr;
mResolveValues.Clear();
}
AllPromiseType* Promise() { return mPromise; }
private:
nsTArray<Maybe<ResolveValueType>> mResolveValues;
@@ -338,18 +338,18 @@ public:
if (aPromises.Length() == 0) {
return AllPromiseType::CreateAndResolve(nsTArray<ResolveValueType>(), __func__);
}
RefPtr<AllPromiseHolder> holder = new AllPromiseHolder(aPromises.Length());
RefPtr<AllPromiseType> promise = holder->Promise();
for (size_t i = 0; i < aPromises.Length(); ++i) {
aPromises[i]->Then(aProcessingTarget, __func__,
- [holder, i] (ResolveValueType aResolveValue) -> void { holder->Resolve(i, Move(aResolveValue)); },
- [holder] (RejectValueType aRejectValue) -> void { holder->Reject(Move(aRejectValue)); }
+ [holder, i] (ResolveValueType aResolveValue) -> void { holder->Resolve(i, std::move(aResolveValue)); },
+ [holder] (RejectValueType aRejectValue) -> void { holder->Reject(std::move(aRejectValue)); }
);
}
return promise;
}
class Request : public MozPromiseRefcountable
{
public:
@@ -621,23 +621,23 @@ protected:
void DoResolveOrRejectInternal(ResolveOrRejectValue& aValue) override
{
if (aValue.IsResolve()) {
InvokeCallbackMethod<SupportChaining::value>(
mThisVal.get(),
mResolveMethod,
MaybeMove(aValue.ResolveValue()),
- Move(mCompletionPromise));
+ std::move(mCompletionPromise));
} else {
InvokeCallbackMethod<SupportChaining::value>(
mThisVal.get(),
mRejectMethod,
MaybeMove(aValue.RejectValue()),
- Move(mCompletionPromise));
+ std::move(mCompletionPromise));
}
// Null out mThisVal after invoking the callback so that any references are
// released predictably on the dispatch thread. Otherwise, it would be
// released on whatever thread last drops its reference to the ThenValue,
// which may or may not be ok.
mThisVal = nullptr;
}
@@ -688,17 +688,17 @@ protected:
return mCompletionPromise;
}
void DoResolveOrRejectInternal(ResolveOrRejectValue& aValue) override
{
InvokeCallbackMethod<SupportChaining::value>(mThisVal.get(),
mResolveRejectMethod,
MaybeMove(aValue),
- Move(mCompletionPromise));
+ std::move(mCompletionPromise));
// Null out mThisVal after invoking the callback so that any references are
// released predictably on the dispatch thread. Otherwise, it would be
// released on whatever thread last drops its reference to the ThenValue,
// which may or may not be ok.
mThisVal = nullptr;
}
@@ -727,18 +727,18 @@ protected:
public:
ThenValue(nsISerialEventTarget* aResponseTarget,
ResolveFunction&& aResolveFunction,
RejectFunction&& aRejectFunction,
const char* aCallSite)
: ThenValueBase(aResponseTarget, aCallSite)
{
- mResolveFunction.emplace(Move(aResolveFunction));
- mRejectFunction.emplace(Move(aRejectFunction));
+ mResolveFunction.emplace(std::move(aResolveFunction));
+ mRejectFunction.emplace(std::move(aRejectFunction));
}
void Disconnect() override
{
ThenValueBase::Disconnect();
// If a Request has been disconnected, we don't guarantee that the
// resolve/reject runnable will be dispatched. Destroy our callbacks
@@ -761,23 +761,23 @@ protected:
// classes with ::operator()), since it allows us to share code more easily.
// We could fix this if need be, though it's quite easy to work around by
// just capturing something.
if (aValue.IsResolve()) {
InvokeCallbackMethod<SupportChaining::value>(
mResolveFunction.ptr(),
&ResolveFunction::operator(),
MaybeMove(aValue.ResolveValue()),
- Move(mCompletionPromise));
+ std::move(mCompletionPromise));
} else {
InvokeCallbackMethod<SupportChaining::value>(
mRejectFunction.ptr(),
&RejectFunction::operator(),
MaybeMove(aValue.RejectValue()),
- Move(mCompletionPromise));
+ std::move(mCompletionPromise));
}
// Destroy callbacks after invocation so that any references in closures are
// released predictably on the dispatch thread. Otherwise, they would be
// released on whatever thread last drops its reference to the ThenValue,
// which may or may not be ok.
mResolveFunction.reset();
mRejectFunction.reset();
@@ -803,17 +803,17 @@ protected:
typename Conditional<SupportChaining::value, R1, MozPromise>::Type;
public:
ThenValue(nsISerialEventTarget* aResponseTarget,
ResolveRejectFunction&& aResolveRejectFunction,
const char* aCallSite)
: ThenValueBase(aResponseTarget, aCallSite)
{
- mResolveRejectFunction.emplace(Move(aResolveRejectFunction));
+ mResolveRejectFunction.emplace(std::move(aResolveRejectFunction));
}
void Disconnect() override
{
ThenValueBase::Disconnect();
// If a Request has been disconnected, we don't guarantee that the
// resolve/reject runnable will be dispatched. Destroy our callbacks
@@ -834,17 +834,17 @@ protected:
// ResolveRejectFunction is capture-lambdas (i.e. anonymous
// classes with ::operator()), since it allows us to share code more easily.
// We could fix this if need be, though it's quite easy to work around by
// just capturing something.
InvokeCallbackMethod<SupportChaining::value>(
mResolveRejectFunction.ptr(),
&ResolveRejectFunction::operator(),
MaybeMove(aValue),
- Move(mCompletionPromise));
+ std::move(mCompletionPromise));
// Destroy callbacks after invocation so that any references in closures are
// released predictably on the dispatch thread. Otherwise, they would be
// released on whatever thread last drops its reference to the ThenValue,
// which may or may not be ok.
mResolveRejectFunction.reset();
}
@@ -980,17 +980,17 @@ public:
template<typename... Functions,
typename ThenValueType = ThenValue<Functions...>,
typename ReturnType = ThenCommand<ThenValueType>>
ReturnType Then(nsISerialEventTarget* aResponseTarget,
const char* aCallSite,
Functions&&... aFunctions)
{
RefPtr<ThenValueType> thenValue =
- new ThenValueType(aResponseTarget, Move(aFunctions)..., aCallSite);
+ new ThenValueType(aResponseTarget, std::move(aFunctions)..., aCallSite);
return ReturnType(aCallSite, thenValue.forget(), this);
}
void ChainTo(already_AddRefed<Private> aChainedPromise, const char* aCallSite)
{
MutexAutoLock lock(mMutex);
MOZ_DIAGNOSTIC_ASSERT(!IsExclusive || !mHaveRequest);
mHaveRequest = true;
@@ -1219,32 +1219,32 @@ public:
}
void Resolve(typename PromiseType::ResolveValueType&& aResolveValue,
const char* aMethodName)
{
if (mMonitor) {
mMonitor->AssertCurrentThreadOwns();
}
MOZ_ASSERT(mPromise);
- mPromise->Resolve(Move(aResolveValue), aMethodName);
+ mPromise->Resolve(std::move(aResolveValue), aMethodName);
mPromise = nullptr;
}
void ResolveIfExists(const typename PromiseType::ResolveValueType& aResolveValue,
const char* aMethodName)
{
if (!IsEmpty()) {
Resolve(aResolveValue, aMethodName);
}
}
void ResolveIfExists(typename PromiseType::ResolveValueType&& aResolveValue,
const char* aMethodName)
{
if (!IsEmpty()) {
- Resolve(Move(aResolveValue), aMethodName);
+ Resolve(std::move(aResolveValue), aMethodName);
}
}
void Reject(const typename PromiseType::RejectValueType& aRejectValue,
const char* aMethodName)
{
if (mMonitor) {
mMonitor->AssertCurrentThreadOwns();
@@ -1255,32 +1255,32 @@ public:
}
void Reject(typename PromiseType::RejectValueType&& aRejectValue,
const char* aMethodName)
{
if (mMonitor) {
mMonitor->AssertCurrentThreadOwns();
}
MOZ_ASSERT(mPromise);
- mPromise->Reject(Move(aRejectValue), aMethodName);
+ mPromise->Reject(std::move(aRejectValue), aMethodName);
mPromise = nullptr;
}
void RejectIfExists(const typename PromiseType::RejectValueType& aRejectValue,
const char* aMethodName)
{
if (!IsEmpty()) {
Reject(aRejectValue, aMethodName);
}
}
void RejectIfExists(typename PromiseType::RejectValueType&& aRejectValue,
const char* aMethodName)
{
if (!IsEmpty()) {
- Reject(Move(aRejectValue), aMethodName);
+ Reject(std::move(aRejectValue), aMethodName);
}
}
private:
Monitor* mMonitor;
RefPtr<typename PromiseType::Private> mPromise;
};
--- a/xpcom/threads/PrioritizedEventQueue.cpp
+++ b/xpcom/threads/PrioritizedEventQueue.cpp
@@ -14,20 +14,20 @@
using namespace mozilla;
template<class InnerQueueT>
PrioritizedEventQueue<InnerQueueT>::PrioritizedEventQueue(UniquePtr<InnerQueueT> aHighQueue,
UniquePtr<InnerQueueT> aInputQueue,
UniquePtr<InnerQueueT> aNormalQueue,
UniquePtr<InnerQueueT> aIdleQueue,
already_AddRefed<nsIIdlePeriod> aIdlePeriod)
- : mHighQueue(Move(aHighQueue))
- , mInputQueue(Move(aInputQueue))
- , mNormalQueue(Move(aNormalQueue))
- , mIdleQueue(Move(aIdleQueue))
+ : mHighQueue(std::move(aHighQueue))
+ , mInputQueue(std::move(aInputQueue))
+ , mNormalQueue(std::move(aNormalQueue))
+ , mIdleQueue(std::move(aIdleQueue))
, mIdlePeriod(aIdlePeriod)
{
static_assert(IsBaseOf<AbstractEventQueue, InnerQueueT>::value,
"InnerQueueT must be an AbstractEventQueue subclass");
}
template<class InnerQueueT>
void
--- a/xpcom/threads/Queue.h
+++ b/xpcom/threads/Queue.h
@@ -46,34 +46,34 @@ public:
MOZ_ASSERT(page);
mTail->mNext = page;
mTail = page;
mOffsetTail = 0;
}
T& eltLocation = mTail->mEvents[mOffsetTail];
- eltLocation = Move(aElement);
+ eltLocation = std::move(aElement);
++mOffsetTail;
return eltLocation;
}
bool IsEmpty() const
{
return !mHead || (mHead == mTail && mOffsetHead == mOffsetTail);
}
T Pop()
{
MOZ_ASSERT(!IsEmpty());
MOZ_ASSERT(mOffsetHead < ItemsPerPage);
MOZ_ASSERT_IF(mHead == mTail, mOffsetHead <= mOffsetTail);
- T result = Move(mHead->mEvents[mOffsetHead++]);
+ T result = std::move(mHead->mEvents[mOffsetHead++]);
MOZ_ASSERT(mOffsetHead <= ItemsPerPage);
// Check if mHead points to empty Page
if (mOffsetHead == ItemsPerPage) {
Page* dead = mHead;
mHead = mHead->mNext;
free(dead);
--- a/xpcom/threads/Scheduler.cpp
+++ b/xpcom/threads/Scheduler.cpp
@@ -34,17 +34,17 @@ namespace mozilla {
namespace detail {
class SchedulerEventQueue final : public SynchronizedEventQueue
{
public:
explicit SchedulerEventQueue(UniquePtr<AbstractEventQueue> aQueue)
: mLock("Scheduler")
, mNonCooperativeCondVar(mLock, "SchedulerNonCoop")
- , mQueue(Move(aQueue))
+ , mQueue(std::move(aQueue))
, mScheduler(nullptr)
{}
bool PutEvent(already_AddRefed<nsIRunnable>&& aEvent,
EventPriority aPriority) final;
void Disconnect(const MutexAutoLock& aProofOfLock) final {}
@@ -226,17 +226,17 @@ size_t SchedulerImpl::sNumThreadsRunning
bool SchedulerImpl::sUnlabeledEventRunning;
bool
SchedulerEventQueue::PutEvent(already_AddRefed<nsIRunnable>&& aEvent,
EventPriority aPriority)
{
// We want to leak the reference when we fail to dispatch it, so that
// we won't release the event in a wrong thread.
- LeakRefPtr<nsIRunnable> event(Move(aEvent));
+ LeakRefPtr<nsIRunnable> event(std::move(aEvent));
nsCOMPtr<nsIThreadObserver> obs;
{
MutexAutoLock lock(mLock);
if (mEventsAreDoomed) {
return false;
}
@@ -501,17 +501,17 @@ SchedulerImpl::Start()
// Put things back to the way they were before we started scheduling.
MOZ_ASSERT(!sUnlabeledEventRunning);
sUnlabeledEventRunning = true;
MOZ_ASSERT(sNumThreadsRunning == 0);
sNumThreadsRunning = 1;
mShuttingDown = false;
- nsTArray<nsCOMPtr<nsIRunnable>> callbacks = Move(mShutdownCallbacks);
+ nsTArray<nsCOMPtr<nsIRunnable>> callbacks = std::move(mShutdownCallbacks);
for (nsIRunnable* runnable : callbacks) {
runnable->Run();
}
}));
}
void
SchedulerImpl::Stop(already_AddRefed<nsIRunnable> aStoppedCallback)
--- a/xpcom/threads/SchedulerGroup.cpp
+++ b/xpcom/threads/SchedulerGroup.cpp
@@ -69,17 +69,17 @@ SchedulerEventTarget::DispatchFromScript
}
NS_IMETHODIMP
SchedulerEventTarget::Dispatch(already_AddRefed<nsIRunnable> aRunnable, uint32_t aFlags)
{
if (NS_WARN_IF(aFlags != NS_DISPATCH_NORMAL)) {
return NS_ERROR_UNEXPECTED;
}
- return mDispatcher->Dispatch(mCategory, Move(aRunnable));
+ return mDispatcher->Dispatch(mCategory, std::move(aRunnable));
}
NS_IMETHODIMP
SchedulerEventTarget::DelayedDispatch(already_AddRefed<nsIRunnable>, uint32_t)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
@@ -96,19 +96,19 @@ SchedulerEventTarget::IsOnCurrentThreadI
return NS_IsMainThread();
}
/* static */ nsresult
SchedulerGroup::UnlabeledDispatch(TaskCategory aCategory,
already_AddRefed<nsIRunnable>&& aRunnable)
{
if (NS_IsMainThread()) {
- return NS_DispatchToCurrentThread(Move(aRunnable));
+ return NS_DispatchToCurrentThread(std::move(aRunnable));
} else {
- return NS_DispatchToMainThread(Move(aRunnable));
+ return NS_DispatchToMainThread(std::move(aRunnable));
}
}
/* static */ void
SchedulerGroup::MarkVsyncReceived()
{
if (gEarliestUnprocessedVsync) {
// If we've seen a vsync already, but haven't handled it, keep the
@@ -142,24 +142,24 @@ SchedulerGroup::SchedulerGroup()
}
}
nsresult
SchedulerGroup::DispatchWithDocGroup(TaskCategory aCategory,
already_AddRefed<nsIRunnable>&& aRunnable,
dom::DocGroup* aDocGroup)
{
- return LabeledDispatch(aCategory, Move(aRunnable), aDocGroup);
+ return LabeledDispatch(aCategory, std::move(aRunnable), aDocGroup);
}
nsresult
SchedulerGroup::Dispatch(TaskCategory aCategory,
already_AddRefed<nsIRunnable>&& aRunnable)
{
- return LabeledDispatch(aCategory, Move(aRunnable), nullptr);
+ return LabeledDispatch(aCategory, std::move(aRunnable), nullptr);
}
nsISerialEventTarget*
SchedulerGroup::EventTargetFor(TaskCategory aCategory) const
{
MOZ_ASSERT(aCategory != TaskCategory::Count);
MOZ_ASSERT(mEventTargets[size_t(aCategory)]);
return mEventTargets[size_t(aCategory)];
@@ -250,17 +250,17 @@ SchedulerGroup::LabeledDispatch(TaskCate
/*static*/ nsresult
SchedulerGroup::InternalUnlabeledDispatch(TaskCategory aCategory,
already_AddRefed<Runnable>&& aRunnable)
{
if (NS_IsMainThread()) {
// NS_DispatchToCurrentThread will not leak the passed in runnable
// when it fails, so we don't need to do anything special.
- return NS_DispatchToCurrentThread(Move(aRunnable));
+ return NS_DispatchToCurrentThread(std::move(aRunnable));
}
RefPtr<Runnable> runnable(aRunnable);
nsresult rv = NS_DispatchToMainThread(do_AddRef(runnable));
if (NS_FAILED(rv)) {
// Dispatch failed. This is a situation where we would have used
// NS_DispatchToMainThread rather than calling into the SchedulerGroup
// machinery, and the caller would be expecting to leak the nsIRunnable
@@ -287,17 +287,17 @@ SchedulerGroup::SetValidatingAccess(Vali
jsapi.Init();
js::EnableAccessValidation(jsapi.cx(), validating);
}
SchedulerGroup::Runnable::Runnable(already_AddRefed<nsIRunnable>&& aRunnable,
SchedulerGroup* aGroup,
dom::DocGroup* aDocGroup)
: mozilla::Runnable("SchedulerGroup::Runnable")
- , mRunnable(Move(aRunnable))
+ , mRunnable(std::move(aRunnable))
, mGroup(aGroup)
, mDocGroup(aDocGroup)
{
}
bool
SchedulerGroup::Runnable::GetAffectedSchedulerGroups(SchedulerGroupSet& aGroups)
{
--- a/xpcom/threads/SharedThreadPool.h
+++ b/xpcom/threads/SharedThreadPool.h
@@ -63,17 +63,17 @@ public:
return Dispatch(event, NS_DISPATCH_AT_END);
}
NS_IMETHOD DispatchFromScript(nsIRunnable *event, uint32_t flags) override {
return Dispatch(event, flags);
}
NS_IMETHOD Dispatch(already_AddRefed<nsIRunnable> event, uint32_t flags = NS_DISPATCH_NORMAL) override
- { return !mEventTarget ? NS_ERROR_NULL_POINTER : mEventTarget->Dispatch(Move(event), flags); }
+ { return !mEventTarget ? NS_ERROR_NULL_POINTER : mEventTarget->Dispatch(std::move(event), flags); }
NS_IMETHOD DelayedDispatch(already_AddRefed<nsIRunnable>, uint32_t) override
{ return NS_ERROR_NOT_IMPLEMENTED; }
using nsIEventTarget::Dispatch;
NS_IMETHOD IsOnCurrentThread(bool *_retval) override { return !mEventTarget ? NS_ERROR_NULL_POINTER : mEventTarget->IsOnCurrentThread(_retval); }
--- a/xpcom/threads/SyncRunnable.h
+++ b/xpcom/threads/SyncRunnable.h
@@ -38,17 +38,17 @@ public:
, mRunnable(aRunnable)
, mMonitor("SyncRunnable")
, mDone(false)
{
}
explicit SyncRunnable(already_AddRefed<nsIRunnable> aRunnable)
: Runnable("SyncRunnable")
- , mRunnable(Move(aRunnable))
+ , mRunnable(std::move(aRunnable))
, mMonitor("SyncRunnable")
, mDone(false)
{
}
void DispatchToThread(nsIEventTarget* aThread, bool aForceDispatch = false)
{
nsresult rv;
--- a/xpcom/threads/SystemGroup.cpp
+++ b/xpcom/threads/SystemGroup.cpp
@@ -78,19 +78,19 @@ SystemGroup::Initialized()
return SystemGroupImpl::Initialized();
}
/* static */ nsresult
SystemGroup::Dispatch(TaskCategory aCategory,
already_AddRefed<nsIRunnable>&& aRunnable)
{
if (!SystemGroupImpl::Initialized()) {
- return NS_DispatchToMainThread(Move(aRunnable));
+ return NS_DispatchToMainThread(std::move(aRunnable));
}
- return SystemGroupImpl::Get()->Dispatch(aCategory, Move(aRunnable));
+ return SystemGroupImpl::Get()->Dispatch(aCategory, std::move(aRunnable));
}
/* static */ nsISerialEventTarget*
SystemGroup::EventTargetFor(TaskCategory aCategory)
{
if (!SystemGroupImpl::Initialized()) {
return GetMainThreadSerialEventTarget();
}
--- a/xpcom/threads/TaskDispatcher.h
+++ b/xpcom/threads/TaskDispatcher.h
@@ -82,17 +82,17 @@ public:
// this is only necessary in the case where this AutoTaskDispatcher can be
// accessed by the direct tasks it dispatches (true for TailDispatchers, but
// potentially not true for other hypothetical AutoTaskDispatchers). Feel
// free to loosen this restriction to apply only to mIsTailDispatcher if a
// use-case requires it.
MOZ_ASSERT(!HaveDirectTasks());
for (size_t i = 0; i < mTaskGroups.Length(); ++i) {
- DispatchTaskGroup(Move(mTaskGroups[i]));
+ DispatchTaskGroup(std::move(mTaskGroups[i]));
}
}
bool HaveDirectTasks() const
{
return mDirectTasks.isSome() && !mDirectTasks->empty();
}
@@ -105,17 +105,17 @@ public:
}
}
void AddDirectTask(already_AddRefed<nsIRunnable> aRunnable) override
{
if (mDirectTasks.isNothing()) {
mDirectTasks.emplace();
}
- mDirectTasks->push(Move(aRunnable));
+ mDirectTasks->push(std::move(aRunnable));
}
void AddStateChangeTask(AbstractThread* aThread,
already_AddRefed<nsIRunnable> aRunnable) override
{
nsCOMPtr<nsIRunnable> r = aRunnable;
MOZ_RELEASE_ASSERT(r);
EnsureTaskGroup(aThread).mStateChangeTasks.AppendElement(r.forget());
@@ -148,17 +148,17 @@ public:
nsresult DispatchTasksFor(AbstractThread* aThread) override
{
nsresult rv = NS_OK;
// Dispatch all groups that match |aThread|.
for (size_t i = 0; i < mTaskGroups.Length(); ++i) {
if (mTaskGroups[i]->mThread == aThread) {
- nsresult rv2 = DispatchTaskGroup(Move(mTaskGroups[i]));
+ nsresult rv2 = DispatchTaskGroup(std::move(mTaskGroups[i]));
if (NS_WARN_IF(NS_FAILED(rv2)) && NS_SUCCEEDED(rv)) {
// We should try our best to call DispatchTaskGroup() as much as
// possible and return an error if any of DispatchTaskGroup() calls
// failed.
rv = rv2;
}
@@ -187,17 +187,17 @@ private:
nsTArray<nsCOMPtr<nsIRunnable>> mRegularTasks;
};
class TaskGroupRunnable : public Runnable
{
public:
explicit TaskGroupRunnable(UniquePtr<PerThreadTaskGroup>&& aTasks)
: Runnable("AutoTaskDispatcher::TaskGroupRunnable")
- , mTasks(Move(aTasks))
+ , mTasks(std::move(aTasks))
{
}
NS_IMETHOD Run() override
{
// State change tasks get run all together before any code is run, so
// that all state changes are made in an atomic unit.
for (size_t i = 0; i < mTasks->mStateChangeTasks.Length(); ++i) {
@@ -256,17 +256,17 @@ private:
}
nsresult DispatchTaskGroup(UniquePtr<PerThreadTaskGroup> aGroup)
{
RefPtr<AbstractThread> thread = aGroup->mThread;
AbstractThread::DispatchReason reason = mIsTailDispatcher ? AbstractThread::TailDispatch
: AbstractThread::NormalDispatch;
- nsCOMPtr<nsIRunnable> r = new TaskGroupRunnable(Move(aGroup));
+ nsCOMPtr<nsIRunnable> r = new TaskGroupRunnable(std::move(aGroup));
return thread->Dispatch(r.forget(), reason);
}
// Direct tasks. We use a Maybe<> because (a) this class is hot, (b)
// mDirectTasks often doesn't get anything put into it, and (c) the
// std::queue implementation in GNU libstdc++ does two largish heap
// allocations when creating a new std::queue.
mozilla::Maybe<std::queue<nsCOMPtr<nsIRunnable>>> mDirectTasks;
--- a/xpcom/threads/TaskQueue.cpp
+++ b/xpcom/threads/TaskQueue.cpp
@@ -78,17 +78,17 @@ TaskQueue::TaskQueue(already_AddRefed<ns
, mIsRunning(false)
, mIsShutdown(false)
, mName(aName)
{
}
TaskQueue::TaskQueue(already_AddRefed<nsIEventTarget> aTarget,
bool aSupportsTailDispatch)
- : TaskQueue(Move(aTarget), "Unnamed", aSupportsTailDispatch)
+ : TaskQueue(std::move(aTarget), "Unnamed", aSupportsTailDispatch)
{
}
TaskQueue::~TaskQueue()
{
MonitorAutoLock mon(mQueueMonitor);
MOZ_ASSERT(mIsShutdown);
}
--- a/xpcom/threads/ThreadEventQueue.cpp
+++ b/xpcom/threads/ThreadEventQueue.cpp
@@ -25,17 +25,17 @@ public:
: mQueue(aQueue)
, mOwner(aOwner)
{
}
bool PutEvent(already_AddRefed<nsIRunnable>&& aEvent,
EventPriority aPriority) final
{
- return mOwner->PutEventInternal(Move(aEvent), aPriority, this);
+ return mOwner->PutEventInternal(std::move(aEvent), aPriority, this);
}
void Disconnect(const MutexAutoLock& aProofOfLock) final
{
mQueue = nullptr;
}
private:
@@ -44,17 +44,17 @@ private:
// This is a non-owning reference. It must live at least until Disconnect is
// called to clear it out.
EventQueue* mQueue;
RefPtr<ThreadEventQueue> mOwner;
};
template<class InnerQueueT>
ThreadEventQueue<InnerQueueT>::ThreadEventQueue(UniquePtr<InnerQueueT> aQueue)
- : mBaseQueue(Move(aQueue))
+ : mBaseQueue(std::move(aQueue))
, mLock("ThreadEventQueue")
, mEventsAvailable(mLock, "EventsAvail")
{
static_assert(IsBaseOf<AbstractEventQueue, InnerQueueT>::value,
"InnerQueueT must be an AbstractEventQueue subclass");
}
template<class InnerQueueT>
@@ -63,28 +63,28 @@ ThreadEventQueue<InnerQueueT>::~ThreadEv
MOZ_ASSERT(mNestedQueues.IsEmpty());
}
template<class InnerQueueT>
bool
ThreadEventQueue<InnerQueueT>::PutEvent(already_AddRefed<nsIRunnable>&& aEvent,
EventPriority aPriority)
{
- return PutEventInternal(Move(aEvent), aPriority, nullptr);
+ return PutEventInternal(std::move(aEvent), aPriority, nullptr);
}
template<class InnerQueueT>
bool
ThreadEventQueue<InnerQueueT>::PutEventInternal(already_AddRefed<nsIRunnable>&& aEvent,
EventPriority aPriority,
NestedSink* aSink)
{
// We want to leak the reference when we fail to dispatch it, so that
// we won't release the event in a wrong thread.
- LeakRefPtr<nsIRunnable> event(Move(aEvent));
+ LeakRefPtr<nsIRunnable> event(std::move(aEvent));
nsCOMPtr<nsIThreadObserver> obs;
{
// Check if the runnable wants to override the passed-in priority.
// Do this outside the lock, so runnables implemented in JS can QI
// (and possibly GC) outside of the lock.
if (InnerQueueT::SupportsPrioritization) {
auto* e = event.get(); // can't do_QueryInterface on LeakRefPtr.
@@ -221,17 +221,17 @@ already_AddRefed<nsISerialEventTarget>
ThreadEventQueue<InnerQueueT>::PushEventQueue()
{
auto queue = MakeUnique<EventQueue>();
RefPtr<NestedSink> sink = new NestedSink(queue.get(), this);
RefPtr<ThreadEventTarget> eventTarget = new ThreadEventTarget(sink, NS_IsMainThread());
MutexAutoLock lock(mLock);
- mNestedQueues.AppendElement(NestedQueueItem(Move(queue), eventTarget));
+ mNestedQueues.AppendElement(NestedQueueItem(std::move(queue), eventTarget));
return eventTarget.forget();
}
template<class InnerQueueT>
void
ThreadEventQueue<InnerQueueT>::PopEventQueue(nsIEventTarget* aTarget)
{
MutexAutoLock lock(mLock);
--- a/xpcom/threads/ThreadEventQueue.h
+++ b/xpcom/threads/ThreadEventQueue.h
@@ -96,17 +96,17 @@ private:
struct NestedQueueItem
{
UniquePtr<EventQueue> mQueue;
RefPtr<ThreadEventTarget> mEventTarget;
NestedQueueItem(UniquePtr<EventQueue> aQueue,
ThreadEventTarget* aEventTarget)
- : mQueue(Move(aQueue))
+ : mQueue(std::move(aQueue))
, mEventTarget(aEventTarget)
{}
};
nsTArray<NestedQueueItem> mNestedQueues;
Mutex mLock;
CondVar mEventsAvailable;
--- a/xpcom/threads/ThreadEventTarget.cpp
+++ b/xpcom/threads/ThreadEventTarget.cpp
@@ -118,17 +118,17 @@ ThreadEventTarget::DispatchFromScript(ns
return Dispatch(do_AddRef(aRunnable), aFlags);
}
NS_IMETHODIMP
ThreadEventTarget::Dispatch(already_AddRefed<nsIRunnable> aEvent, uint32_t aFlags)
{
// We want to leak the reference when we fail to dispatch it, so that
// we won't release the event in a wrong thread.
- LeakRefPtr<nsIRunnable> event(Move(aEvent));
+ LeakRefPtr<nsIRunnable> event(std::move(aEvent));
if (NS_WARN_IF(!event)) {
return NS_ERROR_INVALID_ARG;
}
if (gXPCOMThreadsShutDown && !mIsMainThread) {
NS_ASSERTION(false, "Failed Dispatch after xpcom-shutdown-threads");
return NS_ERROR_ILLEGAL_DURING_SHUTDOWN;
}
@@ -178,17 +178,17 @@ ThreadEventTarget::Dispatch(already_AddR
}
NS_IMETHODIMP
ThreadEventTarget::DelayedDispatch(already_AddRefed<nsIRunnable> aEvent, uint32_t aDelayMs)
{
NS_ENSURE_TRUE(!!aDelayMs, NS_ERROR_UNEXPECTED);
RefPtr<DelayedRunnable> r = new DelayedRunnable(do_AddRef(this),
- Move(aEvent),
+ std::move(aEvent),
aDelayMs);
nsresult rv = r->Init();
NS_ENSURE_SUCCESS(rv, rv);
return Dispatch(r.forget(), NS_DISPATCH_NORMAL);
}
NS_IMETHODIMP
--- a/xpcom/threads/ThrottledEventQueue.cpp
+++ b/xpcom/threads/ThrottledEventQueue.cpp
@@ -262,17 +262,17 @@ public:
if (NS_WARN_IF(NS_FAILED(rv))) {
mExecutor = nullptr;
return rv;
}
}
// Only add the event to the underlying queue if are able to
// dispatch to our base target.
- mEventQueue.PutEvent(Move(aEvent), EventPriority::Normal, lock);
+ mEventQueue.PutEvent(std::move(aEvent), EventPriority::Normal, lock);
return NS_OK;
}
nsresult
DelayedDispatch(already_AddRefed<nsIRunnable> aEvent, uint32_t aDelay)
{
// The base target may implement this, but we don't. Always fail
// to provide consistent behavior.
@@ -340,24 +340,24 @@ ThrottledEventQueue::DispatchFromScript(
{
return mInner->DispatchFromScript(aEvent, aFlags);
}
NS_IMETHODIMP
ThrottledEventQueue::Dispatch(already_AddRefed<nsIRunnable> aEvent,
uint32_t aFlags)
{
- return mInner->Dispatch(Move(aEvent), aFlags);
+ return mInner->Dispatch(std::move(aEvent), aFlags);
}
NS_IMETHODIMP
ThrottledEventQueue::DelayedDispatch(already_AddRefed<nsIRunnable> aEvent,
uint32_t aFlags)
{
- return mInner->DelayedDispatch(Move(aEvent), aFlags);
+ return mInner->DelayedDispatch(std::move(aEvent), aFlags);
}
NS_IMETHODIMP
ThrottledEventQueue::IsOnCurrentThread(bool* aResult)
{
*aResult = mInner->IsOnCurrentThread();
return NS_OK;
}
--- a/xpcom/threads/nsProxyRelease.h
+++ b/xpcom/threads/nsProxyRelease.h
@@ -95,17 +95,17 @@ template<bool nsISupportsBased>
struct ProxyReleaseChooser
{
template<typename T>
static void ProxyRelease(const char* aName,
nsIEventTarget* aTarget,
already_AddRefed<T> aDoomed,
bool aAlwaysProxy)
{
- ::detail::ProxyRelease(aName, aTarget, mozilla::Move(aDoomed), aAlwaysProxy);
+ ::detail::ProxyRelease(aName, aTarget, std::move(aDoomed), aAlwaysProxy);
}
};
template<>
struct ProxyReleaseChooser<true>
{
// We need an intermediate step for handling classes with ambiguous
// inheritance to nsISupports.
@@ -142,17 +142,17 @@ struct ProxyReleaseChooser<true>
* asynchronous release.
*/
template<class T>
inline NS_HIDDEN_(void)
NS_ProxyRelease(const char* aName, nsIEventTarget* aTarget,
already_AddRefed<T> aDoomed, bool aAlwaysProxy = false)
{
::detail::ProxyReleaseChooser<mozilla::IsBaseOf<nsISupports, T>::value>
- ::ProxyRelease(aName, aTarget, mozilla::Move(aDoomed), aAlwaysProxy);
+ ::ProxyRelease(aName, aTarget, std::move(aDoomed), aAlwaysProxy);
}
/**
* Ensures that the delete of a smart pointer occurs on the main thread.
*
* @param aName
* the labelling name of the runnable involved in the releasing
* @param aDoomed
@@ -178,27 +178,27 @@ NS_ReleaseOnMainThreadSystemGroup(const
if (!systemGroupEventTarget) {
MOZ_ASSERT_UNREACHABLE("Could not get main thread; leaking an object!");
mozilla::Unused << aDoomed.take();
return;
}
}
- NS_ProxyRelease(aName, systemGroupEventTarget, mozilla::Move(aDoomed),
+ NS_ProxyRelease(aName, systemGroupEventTarget, std::move(aDoomed),
aAlwaysProxy);
}
template<class T>
inline NS_HIDDEN_(void)
NS_ReleaseOnMainThreadSystemGroup(already_AddRefed<T> aDoomed,
bool aAlwaysProxy = false)
{
NS_ReleaseOnMainThreadSystemGroup("NS_ReleaseOnMainThreadSystemGroup",
- mozilla::Move(aDoomed), aAlwaysProxy);
+ std::move(aDoomed), aAlwaysProxy);
}
/**
* Class to safely handle main-thread-only pointers off the main thread.
*
* Classes like XPCWrappedJS are main-thread-only, which means that it is
* forbidden to call methods on instances of these classes off the main thread.
* For various reasons (see bug 771074), this restriction recently began to
--- a/xpcom/threads/nsThread.cpp
+++ b/xpcom/threads/nsThread.cpp
@@ -644,23 +644,23 @@ nsThread::DispatchFromScript(nsIRunnable
return mEventTarget->Dispatch(event.forget(), aFlags);
}
NS_IMETHODIMP
nsThread::Dispatch(already_AddRefed<nsIRunnable> aEvent, uint32_t aFlags)
{
LOG(("THRD(%p) Dispatch [%p %x]\n", this, /* XXX aEvent */nullptr, aFlags));
- return mEventTarget->Dispatch(Move(aEvent), aFlags);
+ return mEventTarget->Dispatch(std::move(aEvent), aFlags);
}
NS_IMETHODIMP
nsThread::DelayedDispatch(already_AddRefed<nsIRunnable> aEvent, uint32_t aDelayMs)
{
- return mEventTarget->DelayedDispatch(Move(aEvent), aDelayMs);
+ return mEventTarget->DelayedDispatch(std::move(aEvent), aDelayMs);
}
NS_IMETHODIMP
nsThread::IsOnCurrentThread(bool* aResult)
{
return mEventTarget->IsOnCurrentThread(aResult);
}
--- a/xpcom/threads/nsThreadPool.cpp
+++ b/xpcom/threads/nsThreadPool.cpp
@@ -90,17 +90,17 @@ nsThreadPool::PutEvent(already_AddRefed<
if (mThreads.Count() < (int32_t)mThreadLimit &&
!(aFlags & NS_DISPATCH_AT_END) &&
// Spawn a new thread if we don't have enough idle threads to serve
// pending events immediately.
mEvents.Count(lock) >= mIdleCount) {
spawnThread = true;
}
- mEvents.PutEvent(Move(aEvent), EventPriority::Normal, lock);
+ mEvents.PutEvent(std::move(aEvent), EventPriority::Normal, lock);
mEventsAvailable.Notify();
stackSize = mStackSize;
}
LOG(("THRD-P(%p) put [spawn=%d]\n", this, spawnThread));
if (!spawnThread) {
return NS_OK;
}
@@ -261,26 +261,26 @@ nsThreadPool::Dispatch(already_AddRefed<
if (aFlags & DISPATCH_SYNC) {
nsCOMPtr<nsIThread> thread;
nsThreadManager::get().GetCurrentThread(getter_AddRefs(thread));
if (NS_WARN_IF(!thread)) {
return NS_ERROR_NOT_AVAILABLE;
}
RefPtr<nsThreadSyncDispatch> wrapper =
- new nsThreadSyncDispatch(thread.forget(), Move(aEvent));
+ new nsThreadSyncDispatch(thread.forget(), std::move(aEvent));
PutEvent(wrapper);
SpinEventLoopUntil([&, wrapper]() -> bool {
return !wrapper->IsPending();
});
} else {
NS_ASSERTION(aFlags == NS_DISPATCH_NORMAL ||
aFlags == NS_DISPATCH_AT_END, "unexpected dispatch flags");
- PutEvent(Move(aEvent), aFlags);
+ PutEvent(std::move(aEvent), aFlags);
}
return NS_OK;
}
NS_IMETHODIMP
nsThreadPool::DelayedDispatch(already_AddRefed<nsIRunnable>, uint32_t)
{
return NS_ERROR_NOT_IMPLEMENTED;
--- a/xpcom/threads/nsThreadSyncDispatch.h
+++ b/xpcom/threads/nsThreadSyncDispatch.h
@@ -14,17 +14,17 @@
#include "LeakRefPtr.h"
class nsThreadSyncDispatch : public mozilla::Runnable
{
public:
nsThreadSyncDispatch(already_AddRefed<nsIEventTarget> aOrigin, already_AddRefed<nsIRunnable>&& aTask)
: Runnable("nsThreadSyncDispatch")
, mOrigin(aOrigin)
- , mSyncTask(mozilla::Move(aTask))
+ , mSyncTask(std::move(aTask))
, mIsPending(true)
{
}
bool IsPending()
{
// This is an atomic acquire on the origin thread.
return mIsPending;
--- a/xpcom/threads/nsThreadUtils.cpp
+++ b/xpcom/threads/nsThreadUtils.cpp
@@ -86,17 +86,17 @@ NS_IMPL_ISUPPORTS_INHERITED(IdleRunnable
NS_IMPL_ISUPPORTS_INHERITED(PrioritizableRunnable, Runnable,
nsIRunnablePriority)
PrioritizableRunnable::PrioritizableRunnable(already_AddRefed<nsIRunnable>&& aRunnable,
uint32_t aPriority)
// Real runnable name is managed by overridding the GetName function.
: Runnable("PrioritizableRunnable")
- , mRunnable(Move(aRunnable))
+ , mRunnable(std::move(aRunnable))
, mPriority(aPriority)
{
#if DEBUG
nsCOMPtr<nsIRunnablePriority> runnablePrio = do_QueryInterface(mRunnable);
MOZ_ASSERT(!runnablePrio);
#endif
}
@@ -244,17 +244,17 @@ NS_DispatchToCurrentThread(nsIRunnable*
{
nsCOMPtr<nsIRunnable> event(aEvent);
return NS_DispatchToCurrentThread(event.forget());
}
nsresult
NS_DispatchToMainThread(already_AddRefed<nsIRunnable>&& aEvent, uint32_t aDispatchFlags)
{
- LeakRefPtr<nsIRunnable> event(Move(aEvent));
+ LeakRefPtr<nsIRunnable> event(std::move(aEvent));
nsCOMPtr<nsIThread> thread;
nsresult rv = NS_GetMainThread(getter_AddRefs(thread));
if (NS_WARN_IF(NS_FAILED(rv))) {
NS_ASSERTION(false, "Failed NS_DispatchToMainThread() in shutdown; leaking");
// NOTE: if you stop leaking here, adjust Promise::MaybeReportRejected(),
// which assumes a leak here, or split into leaks and no-leaks versions
return rv;
}
@@ -316,25 +316,25 @@ NS_IdleDispatchToThread(already_AddRefed
}
return rv;
}
nsresult
NS_IdleDispatchToCurrentThread(already_AddRefed<nsIRunnable>&& aEvent)
{
- return NS_IdleDispatchToThread(Move(aEvent),
+ return NS_IdleDispatchToThread(std::move(aEvent),
NS_GetCurrentThread());
}
class IdleRunnableWrapper : public IdleRunnable
{
public:
explicit IdleRunnableWrapper(already_AddRefed<nsIRunnable>&& aEvent)
- : mRunnable(Move(aEvent))
+ : mRunnable(std::move(aEvent))
{
}
NS_IMETHOD Run() override
{
if (!mRunnable) {
return NS_OK;
}
@@ -397,17 +397,17 @@ private:
nsCOMPtr<nsIRunnable> mRunnable;
};
extern nsresult
NS_IdleDispatchToThread(already_AddRefed<nsIRunnable>&& aEvent,
uint32_t aTimeout,
nsIThread* aThread)
{
- nsCOMPtr<nsIRunnable> event(Move(aEvent));
+ nsCOMPtr<nsIRunnable> event(std::move(aEvent));
NS_ENSURE_TRUE(event, NS_ERROR_INVALID_ARG);
//XXX Using current thread for now as the nsIEventTarget.
nsIEventTarget* target = mozilla::GetCurrentThreadEventTarget();
if (!target) {
return NS_ERROR_UNEXPECTED;
}
@@ -422,17 +422,17 @@ NS_IdleDispatchToThread(already_AddRefed
return NS_IdleDispatchToThread(event.forget(), aThread);
}
extern nsresult
NS_IdleDispatchToCurrentThread(already_AddRefed<nsIRunnable>&& aEvent,
uint32_t aTimeout)
{
- return NS_IdleDispatchToThread(Move(aEvent), aTimeout,
+ return NS_IdleDispatchToThread(std::move(aEvent), aTimeout,
NS_GetCurrentThread());
}
#ifndef XPCOM_GLUE_AVOID_NSPR
nsresult
NS_ProcessPendingEvents(nsIThread* aThread, PRIntervalTime aTimeout)
{
nsresult rv = NS_OK;
--- a/xpcom/threads/nsThreadUtils.h
+++ b/xpcom/threads/nsThreadUtils.h
@@ -907,17 +907,17 @@ struct IsParameterStorageClass<StoreCopy
template<typename T>
struct StoreCopyPassByRRef
{
typedef typename mozilla::Decay<T>::Type stored_type;
typedef stored_type&& passed_type;
stored_type m;
template <typename A>
MOZ_IMPLICIT StoreCopyPassByRRef(A&& a) : m(mozilla::Forward<A>(a)) {}
- passed_type PassAsParameter() { return mozilla::Move(m); }
+ passed_type PassAsParameter() { return std::move(m); }
};
template<typename S>
struct IsParameterStorageClass<StoreCopyPassByRRef<S>>
: public mozilla::TrueType {};
template<typename T>
struct StoreRefPassByLRef
{
@@ -1095,17 +1095,17 @@ struct NonParameterStorageClass
// Choose storage&passing strategy based on preferred storage type:
// - If IsParameterStorageClass<T>::value is true, use as-is.
// - RC* -> StoreRefPtrPassByPtr<RC> : Store RefPtr<RC>, pass RC*
// ^^ RC quacks like a ref-counted type (i.e., has AddRef and Release methods)
// - const T* -> StoreConstPtrPassByConstPtr<T> : Store const T*, pass const T*
// - T* -> StorePtrPassByPtr<T> : Store T*, pass T*.
// - const T& -> StoreConstRefPassByConstLRef<T>: Store const T&, pass const T&.
// - T& -> StoreRefPassByLRef<T> : Store T&, pass T&.
-// - T&& -> StoreCopyPassByRRef<T> : Store T, pass Move(T).
+// - T&& -> StoreCopyPassByRRef<T> : Store T, pass std::move(T).
// - RefPtr<T>, nsCOMPtr<T>
// -> StoreRefPtrPassByPtr<T> : Store RefPtr<T>, pass T*
// - Other T -> StoreCopyPassByConstLRef<T> : Store T, pass const T&.
// Other available explicit options:
// - StoreCopyPassByValue<T> : Store T, pass T.
// - StoreCopyPassByLRef<T> : Store T, pass T& (of copy!)
// - StoreCopyPassByConstPtr<T> : Store T, pass const T*
// - StoreCopyPassByPtr<T> : Store T, pass T* (of copy!)
@@ -1376,17 +1376,17 @@ using NonOwningIdleRunnableMethodWithTim
// specify in the template arguments. For example, if you want to transfer
// ownership to a runnable, you can write:
//
// RefPtr<T> ptr = ...;
// nsTArray<U> array = ...;
// nsCOMPtr<nsIRunnable> event =
// mozilla::NewRunnableMethod<RefPtr<T>, nsTArray<U>>
// ("description", myObject, &MyClass::DoSomething,
-// Move(ptr), Move(array));
+// std::move(ptr), std::move(array));
//
// and there will be no extra AddRef/Release traffic, or copying of the array.
//
// Each type that you specify as a template argument to NewRunnableMethod
// comes with its own style of storage in the runnable and its own style
// of argument passing to the invoked method. See the comment for
// ParameterStorage above for more details.
//
@@ -1626,17 +1626,17 @@ class nsRevocableEventPtr
public:
nsRevocableEventPtr() : mEvent(nullptr) {}
~nsRevocableEventPtr() { Revoke(); }
const nsRevocableEventPtr& operator=(RefPtr<T>&& aEvent)
{
if (mEvent != aEvent) {
Revoke();
- mEvent = Move(aEvent);
+ mEvent = std::move(aEvent);
}
return *this;
}
void Revoke()
{
if (mEvent) {
mEvent->Revoke();
--- a/xpcom/threads/nsTimerImpl.cpp
+++ b/xpcom/threads/nsTimerImpl.cpp
@@ -81,17 +81,17 @@ NS_NewTimerWithObserver(nsIObserver* aOb
nsIEventTarget* aTarget)
{
nsCOMPtr<nsITimer> timer;
MOZ_TRY(NS_NewTimerWithObserver(getter_AddRefs(timer),
aObserver,
aDelay,
aType,
aTarget));
- return Move(timer);
+ return std::move(timer);
}
nsresult
NS_NewTimerWithObserver(nsITimer** aTimer,
nsIObserver* aObserver,
uint32_t aDelay,
uint32_t aType,
nsIEventTarget* aTarget)
{
@@ -112,17 +112,17 @@ NS_NewTimerWithCallback(nsITimerCallback
nsIEventTarget* aTarget)
{
nsCOMPtr<nsITimer> timer;
MOZ_TRY(NS_NewTimerWithCallback(getter_AddRefs(timer),
aCallback,
aDelay,
aType,
aTarget));
- return Move(timer);
+ return std::move(timer);
}
nsresult
NS_NewTimerWithCallback(nsITimer** aTimer,
nsITimerCallback* aCallback,
uint32_t aDelay,
uint32_t aType,
nsIEventTarget* aTarget)
{
@@ -143,17 +143,17 @@ NS_NewTimerWithCallback(nsITimerCallback
nsIEventTarget* aTarget)
{
nsCOMPtr<nsITimer> timer;
MOZ_TRY(NS_NewTimerWithCallback(getter_AddRefs(timer),
aCallback,
aDelay,
aType,
aTarget));
- return Move(timer);
+ return std::move(timer);
}
nsresult
NS_NewTimerWithCallback(nsITimer** aTimer,
nsITimerCallback* aCallback,
const TimeDuration& aDelay,
uint32_t aType,
nsIEventTarget* aTarget)
{
@@ -178,17 +178,17 @@ NS_NewTimerWithFuncCallback(nsTimerCallb
nsCOMPtr<nsITimer> timer;
MOZ_TRY(NS_NewTimerWithFuncCallback(getter_AddRefs(timer),
aCallback,
aClosure,
aDelay,
aType,
aNameString,
aTarget));
- return Move(timer);
+ return std::move(timer);
}
nsresult
NS_NewTimerWithFuncCallback(nsITimer** aTimer,
nsTimerCallbackFunc aCallback,
void* aClosure,
uint32_t aDelay,
uint32_t aType,
const char* aNameString,
@@ -217,17 +217,17 @@ NS_NewTimerWithFuncCallback(nsTimerCallb
nsCOMPtr<nsITimer> timer;
MOZ_TRY(NS_NewTimerWithFuncCallback(getter_AddRefs(timer),
aCallback,
aClosure,
aDelay,
aType,
aNameCallback,
aTarget));
- return Move(timer);
+ return std::move(timer);
}
nsresult
NS_NewTimerWithFuncCallback(nsITimer** aTimer,
nsTimerCallbackFunc aCallback,
void* aClosure,
uint32_t aDelay,
uint32_t aType,
nsTimerNameCallbackFunc aNameCallback,
@@ -381,17 +381,17 @@ nsTimerImpl::Shutdown()
NS_RELEASE(gThread);
}
nsresult
nsTimerImpl::InitCommon(uint32_t aDelayMS, uint32_t aType,
Callback&& aNewCallback)
{
return InitCommon(TimeDuration::FromMilliseconds(aDelayMS),
- aType, Move(aNewCallback));
+ aType, std::move(aNewCallback));
}
nsresult
nsTimerImpl::InitCommon(const TimeDuration& aDelay, uint32_t aType,
Callback&& newCallback)
{
mMutex.AssertCurrentThreadOwns();
@@ -429,17 +429,17 @@ nsTimerImpl::InitWithFuncCallbackCommon(
Callback cb; // Goes out of scope after the unlock, prevents deadlock
cb.mType = Callback::Type::Function;
cb.mCallback.c = aFunc;
cb.mClosure = aClosure;
cb.mName = aName;
MutexAutoLock lock(mMutex);
- return InitCommon(aDelay, aType, mozilla::Move(cb));
+ return InitCommon(aDelay, aType, std::move(cb));
}
nsresult
nsTimerImpl::InitWithNamedFuncCallback(nsTimerCallbackFunc aFunc,
void* aClosure,
uint32_t aDelay,
uint32_t aType,
const char* aNameString)
@@ -479,33 +479,33 @@ nsTimerImpl::InitHighResolutionWithCallb
}
Callback cb; // Goes out of scope after the unlock, prevents deadlock
cb.mType = Callback::Type::Interface;
cb.mCallback.i = aCallback;
NS_ADDREF(cb.mCallback.i);
MutexAutoLock lock(mMutex);
- return InitCommon(aDelay, aType, mozilla::Move(cb));
+ return InitCommon(aDelay, aType, std::move(cb));
}
nsresult
nsTimerImpl::Init(nsIObserver* aObserver, uint32_t aDelay, uint32_t aType)
{
if (NS_WARN_IF(!aObserver)) {
return NS_ERROR_INVALID_ARG;
}
Callback cb; // Goes out of scope after the unlock, prevents deadlock
cb.mType = Callback::Type::Observer;
cb.mCallback.o = aObserver;
NS_ADDREF(cb.mCallback.o);
MutexAutoLock lock(mMutex);
- return InitCommon(aDelay, aType, mozilla::Move(cb));
+ return InitCommon(aDelay, aType, std::move(cb));
}
nsresult
nsTimerImpl::Cancel()
{
CancelImpl(false);
return NS_OK;
}