--- a/dom/base/nsContentIterator.cpp
+++ b/dom/base/nsContentIterator.cpp
@@ -12,17 +12,16 @@
 #include "nsCOMPtr.h"
 #include "nsTArray.h"
 #include "nsContentUtils.h"
 #include "nsINode.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsElementTable.h"
 
 using mozilla::DebugOnly;
-using mozilla::Move;
 using mozilla::RawRangeBoundary;
 
 // couple of utility static functs
 
 ///////////////////////////////////////////////////////////////////////////
 // NodeIsInTraversalRange: returns true if content is visited during
 // the traversal of the range in the specified mode.
 //

--- a/dom/xslt/xpath/XPathExpression.cpp
+++ b/dom/xslt/xpath/XPathExpression.cpp
@@ -12,18 +12,16 @@
 #include "nsINode.h"
 #include "XPathResult.h"
 #include "txURIUtils.h"
 #include "txXPathTreeWalker.h"
 #include "mozilla/dom/BindingUtils.h"
 #include "mozilla/dom/Text.h"
 #include "mozilla/dom/XPathResultBinding.h"
 
-using mozilla::Move;
-
 namespace mozilla {
 namespace dom {
 
 class EvalContextImpl : public txIEvalContext
 {
 public:
     EvalContextImpl(const txXPathNode& aContextNode,
                     uint32_t aContextPosition, uint32_t aContextSize,

--- a/dom/xslt/xpath/txExprParser.cpp
+++ b/dom/xslt/xpath/txExprParser.cpp
@@ -16,18 +16,16 @@
 #include "txStack.h"
 #include "nsGkAtoms.h"
 #include "nsError.h"
 #include "txIXPathContext.h"
 #include "txStringUtils.h"
 #include "txXPathNode.h"
 #include "txXPathOptimizer.h"
 
-using mozilla::Move;
-
 /**
  * Creates an Attribute Value Template using the given value
  * This should move to XSLProcessor class
  */
 nsresult
 txExprParser::createAVT(const nsAString& aAttrValue,
                         txIParseContext* aContext,
                         Expr** aResult)

--- a/dom/xslt/xslt/txInstructions.cpp
+++ b/dom/xslt/xslt/txInstructions.cpp
@@ -14,18 +14,16 @@
 #include "nsServiceManagerUtils.h"
 #include "txStringUtils.h"
 #include "nsGkAtoms.h"
 #include "txRtfHandler.h"
 #include "txNodeSorter.h"
 #include "txXSLTNumber.h"
 #include "txExecutionState.h"
 
-using mozilla::Move;
-
 nsresult
 txApplyDefaultElementTemplate::execute(txExecutionState& aEs)
 {
     txExecutionState::TemplateRule* rule = aEs.getCurrentTemplateRule();
     txExpandedName mode(rule->mModeNsId, rule->mModeLocalName);
     txStylesheet::ImportFrame* frame = 0;
     txInstruction* templ;
     nsresult rv =

--- a/dom/xslt/xslt/txRtfHandler.cpp
+++ b/dom/xslt/xslt/txRtfHandler.cpp
@@ -1,18 +1,16 @@
 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "txRtfHandler.h"
 #include "mozilla/Move.h"
 
-using mozilla::Move;
-
 txResultTreeFragment::txResultTreeFragment(nsAutoPtr<txResultBuffer>&& aBuffer)
     : txAExprResult(nullptr),
       mBuffer(std::move(aBuffer))
 {
 }
 
 short txResultTreeFragment::getResultType()
 {

--- a/dom/xslt/xslt/txStylesheet.cpp
+++ b/dom/xslt/xslt/txStylesheet.cpp
@@ -12,17 +12,16 @@
 #include "txToplevelItems.h"
 #include "txInstructions.h"
 #include "txXSLTFunctions.h"
 #include "txLog.h"
 #include "txKey.h"
 #include "txXPathTreeWalker.h"
 
 using mozilla::LogLevel;
-using mozilla::Move;
 
 txStylesheet::txStylesheet()
     : mRootFrame(nullptr)
 {
 }
 
 nsresult
 txStylesheet::init()

--- a/dom/xslt/xslt/txToplevelItems.cpp
+++ b/dom/xslt/xslt/txToplevelItems.cpp
@@ -5,18 +5,16 @@
 
 #include "txToplevelItems.h"
 
 #include "mozilla/Move.h"
 #include "txStylesheet.h"
 #include "txInstructions.h"
 #include "txXSLTPatterns.h"
 
-using mozilla::Move;
-
 TX_IMPL_GETTYPE(txAttributeSetItem, txToplevelItem::attributeSet)
 TX_IMPL_GETTYPE(txImportItem, txToplevelItem::import)
 TX_IMPL_GETTYPE(txOutputItem, txToplevelItem::output)
 TX_IMPL_GETTYPE(txDummyItem, txToplevelItem::dummy)
 
 TX_IMPL_GETTYPE(txStripSpaceItem, txToplevelItem::stripSpace)
 
 txStripSpaceItem::~txStripSpaceItem()

--- a/dom/xslt/xslt/txUnknownHandler.cpp
+++ b/dom/xslt/xslt/txUnknownHandler.cpp
@@ -6,18 +6,16 @@
 #include "txUnknownHandler.h"
 
 #include "mozilla/Move.h"
 #include "txExecutionState.h"
 #include "txStringUtils.h"
 #include "txStylesheet.h"
 #include "nsGkAtoms.h"
 
-using mozilla::Move;
-
 txUnknownHandler::txUnknownHandler(txExecutionState* aEs)
     : mEs(aEs),
       mFlushed(false)
 {
     MOZ_COUNT_CTOR_INHERITED(txUnknownHandler, txBufferingHandler);
 }
 
 txUnknownHandler::~txUnknownHandler()

--- a/image/imgRequestProxy.cpp
+++ b/image/imgRequestProxy.cpp
@@ -15,17 +15,16 @@
 #include "imgINotificationObserver.h"
 #include "mozilla/dom/TabGroup.h"       // for TabGroup
 #include "mozilla/dom/DocGroup.h"       // for DocGroup
 #include "mozilla/Move.h"
 #include "mozilla/Telemetry.h"          // for Telemetry
 
 using namespace mozilla;
 using namespace mozilla::image;
-using mozilla::Move;
 
 // The split of imgRequestProxy and imgRequestProxyStatic means that
 // certain overridden functions need to be usable in the destructor.
 // Since virtual functions can't be used in that way, this class
 // provides a behavioural trait for each class to use instead.
 class ProxyBehaviour
 {
  public:

--- a/ipc/chromium/src/base/message_loop.cc
+++ b/ipc/chromium/src/base/message_loop.cc
@@ -36,17 +36,16 @@
 #endif
 
 #include "MessagePump.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
-using mozilla::Move;
 using mozilla::Runnable;
 
 static base::ThreadLocalPointer<MessageLoop>& get_tls_ptr() {
   static base::ThreadLocalPointer<MessageLoop> tls_ptr;
   return tls_ptr;
 }
 
 //------------------------------------------------------------------------------

--- a/ipc/glue/MessageChannel.cpp
+++ b/ipc/glue/MessageChannel.cpp
@@ -25,18 +25,16 @@
 #include "nsContentUtils.h"
 #include <math.h>
 
 #ifdef MOZ_TASK_TRACER
 #include "GeckoTaskTracer.h"
 using namespace mozilla::tasktracer;
 #endif
 
-using mozilla::Move;
-
 // Undo the damage done by mozzconf.h
 #undef compress
 
 static mozilla::LazyLogModule sLogModule("ipc");
 #define IPC_LOG(...) MOZ_LOG(sLogModule, LogLevel::Debug, (__VA_ARGS__))
 
 /*
  * IPC design:

--- a/ipc/mscom/InterceptorLog.cpp
+++ b/ipc/mscom/InterceptorLog.cpp
@@ -32,17 +32,16 @@
 #include "prenv.h"
 
 #include <callobj.h>
 
 using mozilla::DebugOnly;
 using mozilla::mscom::ArrayData;
 using mozilla::mscom::FindArrayData;
 using mozilla::mscom::IsValidGUID;
-using mozilla::Move;
 using mozilla::Mutex;
 using mozilla::MutexAutoLock;
 using mozilla::NewNonOwningRunnableMethod;
 using mozilla::services::GetObserverService;
 using mozilla::StaticAutoPtr;
 using mozilla::TimeDuration;
 using mozilla::TimeStamp;
 using mozilla::Unused;

--- a/js/public/UbiNode.h
+++ b/js/public/UbiNode.h
@@ -173,17 +173,16 @@ class StackFrame;
 } // namespace ubi
 } // namespace JS
 
 namespace JS {
 namespace ubi {
 
 using mozilla::Forward;
 using mozilla::Maybe;
-using mozilla::Move;
 using mozilla::RangedPtr;
 using mozilla::Variant;
 
 template <typename T>
 using Vector = mozilla::Vector<T, 0, js::SystemAllocPolicy>;
 
 /*** ubi::StackFrame ******************************************************************************/
 

--- a/js/src/builtin/TestingFunctions.cpp
+++ b/js/src/builtin/TestingFunctions.cpp
@@ -69,17 +69,16 @@
 #include "vm/JSObject-inl.h"
 #include "vm/NativeObject-inl.h"
 #include "vm/StringType-inl.h"
 
 using namespace js;
 
 using mozilla::ArrayLength;
 using mozilla::Maybe;
-using mozilla::Move;
 
 // If fuzzingSafe is set, remove functionality that could cause problems with
 // fuzzers. Set this via the environment variable MOZ_FUZZING_SAFE.
 mozilla::Atomic<bool> fuzzingSafe(false);
 
 // If disableOOMFunctions is set, disable functionality that causes artificial
 // OOM conditions.
 static mozilla::Atomic<bool> disableOOMFunctions(false);

--- a/js/src/ds/OrderedHashTable.h
+++ b/js/src/ds/OrderedHashTable.h
@@ -36,17 +36,16 @@
  *     bool isEmpty(const Key&);
  *     void makeEmpty(Key*);
  */
 
 #include "mozilla/HashFunctions.h"
 #include "mozilla/Move.h"
 
 using mozilla::Forward;
-using mozilla::Move;
 
 namespace js {
 
 namespace detail {
 
 /*
  * detail::OrderedHashTable is the underlying data structure used to implement both
  * OrderedHashMap and OrderedHashSet. Programs should use one of those two

--- a/js/src/frontend/Parser.cpp
+++ b/js/src/frontend/Parser.cpp
@@ -48,17 +48,16 @@
 #include "vm/EnvironmentObject-inl.h"
 #include "vm/JSAtom-inl.h"
 #include "vm/JSScript-inl.h"
 
 using namespace js;
 using namespace js::gc;
 
 using mozilla::Maybe;
-using mozilla::Move;
 using mozilla::Nothing;
 using mozilla::PodCopy;
 using mozilla::PodZero;
 using mozilla::Some;
 
 using JS::AutoGCRooter;
 
 namespace js {

--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -253,17 +253,16 @@
 #include "vm/Stack-inl.h"
 #include "vm/StringType-inl.h"
 
 using namespace js;
 using namespace js::gc;
 
 using mozilla::ArrayLength;
 using mozilla::Maybe;
-using mozilla::Move;
 using mozilla::Swap;
 using mozilla::TimeStamp;
 
 using JS::AutoGCRooter;
 
 /*
  * Default settings for tuning the GC.  Some of these can be set at runtime,
  * This list is not complete, some tuning parameters are not listed here.

--- a/js/src/irregexp/RegExpParser.cpp
+++ b/js/src/irregexp/RegExpParser.cpp
@@ -37,17 +37,16 @@
 #include "gc/GC.h"
 #include "irregexp/RegExpCharacters.h"
 #include "util/StringBuffer.h"
 #include "vm/ErrorReporting.h"
 
 using namespace js;
 using namespace js::irregexp;
 
-using mozilla::Move;
 using mozilla::PointerRangeSize;
 
 // ----------------------------------------------------------------------------
 // RegExpBuilder
 
 RegExpBuilder::RegExpBuilder(LifoAlloc* alloc)
   : alloc(alloc),
     pending_empty_(false),

--- a/js/src/jsfriendapi.cpp
+++ b/js/src/jsfriendapi.cpp
@@ -33,17 +33,16 @@
 #include "gc/Nursery-inl.h"
 #include "vm/EnvironmentObject-inl.h"
 #include "vm/JSObject-inl.h"
 #include "vm/JSScript-inl.h"
 #include "vm/NativeObject-inl.h"
 
 using namespace js;
 
-using mozilla::Move;
 using mozilla::PodArrayZero;
 
 JS::RootingContext::RootingContext()
   : autoGCRooters_(nullptr), realm_(nullptr), zone_(nullptr)
 {
     for (auto& stackRootPtr : stackRoots_)
         stackRootPtr = nullptr;
 

--- a/js/src/vm/ErrorReporting.cpp
+++ b/js/src/vm/ErrorReporting.cpp
@@ -12,18 +12,16 @@
 
 #include "jsexn.h"
 #include "jsfriendapi.h"
 
 #include "vm/JSContext.h"
 
 #include "vm/JSContext-inl.h"
 
-using mozilla::Move;
-
 using JS::HandleObject;
 using JS::HandleValue;
 using JS::UniqueTwoByteChars;
 
 void
 js::CallWarningReporter(JSContext* cx, JSErrorReport* reportp)
 {
     MOZ_ASSERT(reportp);

--- a/js/src/vm/MemoryMetrics.cpp
+++ b/js/src/vm/MemoryMetrics.cpp
@@ -25,17 +25,16 @@
 #include "vm/StringType.h"
 #include "vm/SymbolType.h"
 #include "vm/WrapperObject.h"
 #include "wasm/WasmInstance.h"
 #include "wasm/WasmJS.h"
 #include "wasm/WasmModule.h"
 
 using mozilla::MallocSizeOf;
-using mozilla::Move;
 using mozilla::PodCopy;
 
 using namespace js;
 
 using JS::RuntimeStats;
 using JS::ObjectPrivateVisitor;
 using JS::ZoneStats;
 using JS::RealmStats;

--- a/js/src/vm/SavedStacks.cpp
+++ b/js/src/vm/SavedStacks.cpp
@@ -38,17 +38,16 @@
 #include "vm/GeckoProfiler-inl.h"
 #include "vm/JSContext-inl.h"
 #include "vm/NativeObject-inl.h"
 #include "vm/Stack-inl.h"
 
 using mozilla::AddToHash;
 using mozilla::DebugOnly;
 using mozilla::Maybe;
-using mozilla::Move;
 using mozilla::Nothing;
 using mozilla::Some;
 
 namespace js {
 
 /**
  * Maximum number of saved frames returned for an async stack.
  */

--- a/js/src/vm/Scope.cpp
+++ b/js/src/vm/Scope.cpp
@@ -15,17 +15,16 @@
 #include "wasm/WasmInstance.h"
 
 #include "gc/ObjectKind-inl.h"
 #include "vm/Shape-inl.h"
 
 using namespace js;
 
 using mozilla::Maybe;
-using mozilla::Move;
 
 const char*
 js::BindingKindString(BindingKind kind)
 {
     switch (kind) {
       case BindingKind::Import:
         return "import";
       case BindingKind::FormalParameter:

--- a/js/src/vm/TypeInference.cpp
+++ b/js/src/vm/TypeInference.cpp
@@ -42,17 +42,16 @@
 #include "vm/JSScript-inl.h"
 #include "vm/NativeObject-inl.h"
 
 using namespace js;
 using namespace js::gc;
 
 using mozilla::DebugOnly;
 using mozilla::Maybe;
-using mozilla::Move;
 using mozilla::PodArrayZero;
 using mozilla::PodCopy;
 using mozilla::PodZero;
 
 #ifdef DEBUG
 
 static inline jsid
 id___proto__(JSContext* cx)

--- a/js/src/wasm/AsmJS.cpp
+++ b/js/src/wasm/AsmJS.cpp
@@ -61,17 +61,16 @@ using namespace js::wasm;
 
 using mozilla::CeilingLog2;
 using mozilla::Compression::LZ4;
 using mozilla::HashGeneric;
 using mozilla::IsNaN;
 using mozilla::IsNegativeZero;
 using mozilla::IsPositiveZero;
 using mozilla::IsPowerOfTwo;
-using mozilla::Move;
 using mozilla::PodEqual;
 using mozilla::PodZero;
 using mozilla::PositiveInfinity;
 using mozilla::Unused;
 using JS::AsmJSOption;
 using JS::GenericNaN;
 
 /*****************************************************************************/

--- a/js/src/wasm/WasmTypes.h
+++ b/js/src/wasm/WasmTypes.h
@@ -75,17 +75,16 @@ typedef GCVector<WasmGlobalObject*, 0, S
 typedef Rooted<WasmGlobalObject*> RootedWasmGlobalObject;
 
 namespace wasm {
 
 using mozilla::Atomic;
 using mozilla::DebugOnly;
 using mozilla::EnumeratedArray;
 using mozilla::Maybe;
-using mozilla::Move;
 using mozilla::MallocSizeOf;
 using mozilla::Nothing;
 using mozilla::PodZero;
 using mozilla::PodCopy;
 using mozilla::PodEqual;
 using mozilla::Some;
 using mozilla::Unused;
 

--- a/mfbt/tests/TestMaybe.cpp
+++ b/mfbt/tests/TestMaybe.cpp
@@ -12,17 +12,16 @@
 #include "mozilla/Move.h"
 #include "mozilla/TemplateLib.h"
 #include "mozilla/Types.h"
 #include "mozilla/TypeTraits.h"
 #include "mozilla/UniquePtr.h"
 
 using mozilla::IsSame;
 using mozilla::Maybe;
-using mozilla::Move;
 using mozilla::Nothing;
 using mozilla::Some;
 using mozilla::Swap;
 using mozilla::ToMaybe;
 using mozilla::UniquePtr;
 
 #define RUN_TEST(t) \
   do { \

--- a/mfbt/tests/TestNonDereferenceable.cpp
+++ b/mfbt/tests/TestNonDereferenceable.cpp
@@ -4,17 +4,16 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/NonDereferenceable.h"
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Move.h"
 
-using mozilla::Move;
 using mozilla::NonDereferenceable;
 
 #define CHECK MOZ_RELEASE_ASSERT
 
 void
 TestNonDereferenceableSimple()
 {
   // Default construction.

--- a/mfbt/tests/TestTuple.cpp
+++ b/mfbt/tests/TestTuple.cpp
@@ -14,17 +14,16 @@
 
 #include <stddef.h>
 #include <utility>
 
 using mozilla::Get;
 using mozilla::IsSame;
 using mozilla::MakeTuple;
 using mozilla::MakeUnique;
-using mozilla::Move;
 using mozilla::Pair;
 using mozilla::Tie;
 using mozilla::Tuple;
 using mozilla::UniquePtr;
 using mozilla::Unused;
 using std::pair;
 
 #define CHECK(c) \

--- a/mfbt/tests/TestVector.cpp
+++ b/mfbt/tests/TestVector.cpp
@@ -5,17 +5,16 @@
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/Move.h"
 #include "mozilla/UniquePtr.h"
 #include "mozilla/Vector.h"
 
 using mozilla::detail::VectorTesting;
 using mozilla::MakeUnique;
-using mozilla::Move;
 using mozilla::UniquePtr;
 using mozilla::Vector;
 
 struct mozilla::detail::VectorTesting
 {
   static void testReserved();
   static void testConstRange();
   static void testEmplaceBack();

--- a/netwerk/base/nsMIMEInputStream.cpp
+++ b/netwerk/base/nsMIMEInputStream.cpp
@@ -22,17 +22,16 @@
 #include "nsIClassInfoImpl.h"
 #include "nsIIPCSerializableInputStream.h"
 #include "mozilla/Move.h"
 #include "mozilla/Mutex.h"
 #include "mozilla/ipc/InputStreamUtils.h"
 
 using namespace mozilla::ipc;
 using mozilla::Maybe;
-using mozilla::Move;
 
 class nsMIMEInputStream : public nsIMIMEInputStream,
                           public nsISeekableStream,
                           public nsIIPCSerializableInputStream,
                           public nsIAsyncInputStream,
                           public nsIInputStreamCallback,
                           public nsIInputStreamLength,
                           public nsIAsyncInputStreamLength,

--- a/toolkit/components/telemetry/TelemetryEvent.cpp
+++ b/toolkit/components/telemetry/TelemetryEvent.cpp
@@ -27,17 +27,16 @@
 #include "TelemetryEventData.h"
 #include "TelemetryScalar.h"
 #include "ipc/TelemetryIPCAccumulator.h"
 
 using mozilla::StaticMutex;
 using mozilla::StaticMutexAutoLock;
 using mozilla::ArrayLength;
 using mozilla::Maybe;
-using mozilla::Move;
 using mozilla::Nothing;
 using mozilla::StaticAutoPtr;
 using mozilla::TimeStamp;
 using mozilla::Telemetry::Common::AutoHashtable;
 using mozilla::Telemetry::Common::IsExpiredVersion;
 using mozilla::Telemetry::Common::CanRecordDataset;
 using mozilla::Telemetry::Common::IsInDataset;
 using mozilla::Telemetry::Common::MsSinceProcessStart;

--- a/xpcom/threads/nsTimerImpl.cpp
+++ b/xpcom/threads/nsTimerImpl.cpp
@@ -29,17 +29,16 @@ using namespace mozilla::tasktracer;
 #endif
 #else
 #include <unistd.h>
 #endif
 
 using mozilla::Atomic;
 using mozilla::LogLevel;
 using mozilla::MakeRefPtr;
-using mozilla::Move;
 using mozilla::MutexAutoLock;
 using mozilla::TimeDuration;
 using mozilla::TimeStamp;
 
 static TimerThread*     gThread = nullptr;
 
 // This module prints info about the precision of timers.
 static mozilla::LazyLogModule sTimerLog("nsTimerImpl");