--- a/dom/media/fake-cdm/cdm-test-decryptor.cpp
+++ b/dom/media/fake-cdm/cdm-test-decryptor.cpp
@@ -15,39 +15,37 @@
 #include <iterator>
 #include <sstream>
 #include <set>
 #include <thread>
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Attributes.h"
 
-using namespace std;
-
 FakeDecryptor* FakeDecryptor::sInstance = nullptr;
 
 class TestManager {
  public:
   TestManager() = default;
 
   // Register a test with the test manager.
-  void BeginTest(const string& aTestID) {
+  void BeginTest(const std::string& aTestID) {
     std::lock_guard<std::mutex> lock(mMutex);
     auto found = mTestIDs.find(aTestID);
     if (found == mTestIDs.end()) {
       mTestIDs.insert(aTestID);
     } else {
       Error("FAIL BeginTest test already existed: " + aTestID);
     }
   }
 
   // Notify the test manager that the test is finished. If all tests are done,
   // test manager will send "test-storage complete" to notify the parent that
   // all tests are finished and also delete itself.
-  void EndTest(const string& aTestID) {
+  void EndTest(const std::string& aTestID) {
     bool isEmpty = false;
     {
       std::lock_guard<std::mutex> lock(mMutex);
       auto found = mTestIDs.find(aTestID);
       if (found != mTestIDs.end()) {
         mTestIDs.erase(aTestID);
         isEmpty = mTestIDs.empty();
       } else {
@@ -59,22 +57,22 @@ class TestManager {
       Finish();
       delete this;
     }
   }
 
  private:
   ~TestManager() = default;
 
-  static void Error(const string& msg) { FakeDecryptor::Message(msg); }
+  static void Error(const std::string& msg) { FakeDecryptor::Message(msg); }
 
   static void Finish() { FakeDecryptor::Message("test-storage complete"); }
 
   std::mutex mMutex;
-  set<string> mTestIDs;
+  std::set<std::string> mTestIDs;
 };
 
 FakeDecryptor::FakeDecryptor(cdm::Host_10* aHost) : mHost(aHost) {
   MOZ_ASSERT(!sInstance);
   sInstance = this;
 }
 
 void FakeDecryptor::Message(const std::string& aMessage) {
@@ -86,248 +84,253 @@ void FakeDecryptor::Message(const std::s
 }
 
 std::vector<std::string> Tokenize(const std::string& aString) {
   std::stringstream strstr(aString);
   std::istream_iterator<std::string> it(strstr), end;
   return std::vector<std::string>(it, end);
 }
 
-static const string TruncateRecordId = "truncate-record-id";
-static const string TruncateRecordData = "I will soon be truncated";
+static const std::string TruncateRecordId = "truncate-record-id";
+static const std::string TruncateRecordData = "I will soon be truncated";
 
 template <class Continuation>
 class WriteRecordSuccessTask {
  public:
-  WriteRecordSuccessTask(string aId, Continuation aThen)
-      : mId(aId), mThen(move(aThen)) {}
+  WriteRecordSuccessTask(std::string aId, Continuation aThen)
+      : mId(aId), mThen(std::move(aThen)) {}
 
   void operator()() { ReadRecord(FakeDecryptor::sInstance->mHost, mId, mThen); }
 
-  string mId;
+  std::string mId;
   Continuation mThen;
 };
 
 class WriteRecordFailureTask {
  public:
-  explicit WriteRecordFailureTask(const string& aMessage,
+  explicit WriteRecordFailureTask(const std::string& aMessage,
                                   TestManager* aTestManager = nullptr,
-                                  const string& aTestID = "")
+                                  const std::string& aTestID = "")
       : mMessage(aMessage), mTestmanager(aTestManager), mTestID(aTestID) {}
 
   void operator()() {
     FakeDecryptor::Message(mMessage);
     if (mTestmanager) {
       mTestmanager->EndTest(mTestID);
     }
   }
 
  private:
-  string mMessage;
+  std::string mMessage;
   TestManager* const mTestmanager;
-  const string mTestID;
+  const std::string mTestID;
 };
 
 class TestEmptyContinuation : public ReadContinuation {
  public:
-  TestEmptyContinuation(TestManager* aTestManager, const string& aTestID)
+  TestEmptyContinuation(TestManager* aTestManager, const std::string& aTestID)
       : mTestmanager(aTestManager), mTestID(aTestID) {}
 
   virtual void operator()(bool aSuccess, const uint8_t* aData,
                           uint32_t aDataSize) override {
     if (aDataSize) {
       FakeDecryptor::Message(
           "FAIL TestEmptyContinuation record was not truncated");
     }
     mTestmanager->EndTest(mTestID);
   }
 
  private:
   TestManager* const mTestmanager;
-  const string mTestID;
+  const std::string mTestID;
 };
 
 class TruncateContinuation : public ReadContinuation {
  public:
-  TruncateContinuation(const string& aID, TestManager* aTestManager,
-                       const string& aTestID)
+  TruncateContinuation(const std::string& aID, TestManager* aTestManager,
+                       const std::string& aTestID)
       : mID(aID), mTestmanager(aTestManager), mTestID(aTestID) {}
 
   virtual void operator()(bool aSuccess, const uint8_t* aData,
                           uint32_t aDataSize) override {
-    if (string(reinterpret_cast<const char*>(aData), aDataSize) !=
+    if (std::string(reinterpret_cast<const char*>(aData), aDataSize) !=
         TruncateRecordData) {
       FakeDecryptor::Message(
           "FAIL TruncateContinuation read data doesn't match written data");
     }
     auto cont = TestEmptyContinuation(mTestmanager, mTestID);
     auto msg = "FAIL in TruncateContinuation write.";
     WriteRecord(FakeDecryptor::sInstance->mHost, mID, nullptr, 0,
                 WriteRecordSuccessTask<TestEmptyContinuation>(mID, cont),
                 WriteRecordFailureTask(msg, mTestmanager, mTestID));
   }
 
  private:
-  const string mID;
+  const std::string mID;
   TestManager* const mTestmanager;
-  const string mTestID;
+  const std::string mTestID;
 };
 
 class VerifyAndFinishContinuation : public ReadContinuation {
  public:
-  explicit VerifyAndFinishContinuation(string aValue, TestManager* aTestManager,
-                                       const string& aTestID)
+  explicit VerifyAndFinishContinuation(std::string aValue,
+                                       TestManager* aTestManager,
+                                       const std::string& aTestID)
       : mValue(aValue), mTestmanager(aTestManager), mTestID(aTestID) {}
 
   virtual void operator()(bool aSuccess, const uint8_t* aData,
                           uint32_t aDataSize) override {
-    if (string(reinterpret_cast<const char*>(aData), aDataSize) != mValue) {
+    if (std::string(reinterpret_cast<const char*>(aData), aDataSize) !=
+        mValue) {
       FakeDecryptor::Message(
           "FAIL VerifyAndFinishContinuation read data doesn't match expected "
           "data");
     }
     mTestmanager->EndTest(mTestID);
   }
 
  private:
-  string mValue;
+  std::string mValue;
   TestManager* const mTestmanager;
-  const string mTestID;
+  const std::string mTestID;
 };
 
 class VerifyAndOverwriteContinuation : public ReadContinuation {
  public:
-  VerifyAndOverwriteContinuation(string aId, string aValue, string aOverwrite,
+  VerifyAndOverwriteContinuation(std::string aId, std::string aValue,
+                                 std::string aOverwrite,
                                  TestManager* aTestManager,
-                                 const string& aTestID)
+                                 const std::string& aTestID)
       : mId(aId),
         mValue(aValue),
         mOverwrite(aOverwrite),
         mTestmanager(aTestManager),
         mTestID(aTestID) {}
 
   virtual void operator()(bool aSuccess, const uint8_t* aData,
                           uint32_t aDataSize) override {
-    if (string(reinterpret_cast<const char*>(aData), aDataSize) != mValue) {
+    if (std::string(reinterpret_cast<const char*>(aData), aDataSize) !=
+        mValue) {
       FakeDecryptor::Message(
           "FAIL VerifyAndOverwriteContinuation read data doesn't match "
           "expected data");
     }
     auto cont = VerifyAndFinishContinuation(mOverwrite, mTestmanager, mTestID);
     auto msg = "FAIL in VerifyAndOverwriteContinuation write.";
     WriteRecord(FakeDecryptor::sInstance->mHost, mId, mOverwrite,
                 WriteRecordSuccessTask<VerifyAndFinishContinuation>(mId, cont),
                 WriteRecordFailureTask(msg, mTestmanager, mTestID));
   }
 
  private:
-  string mId;
-  string mValue;
-  string mOverwrite;
+  std::string mId;
+  std::string mValue;
+  std::string mOverwrite;
   TestManager* const mTestmanager;
-  const string mTestID;
+  const std::string mTestID;
 };
 
-static const string OpenAgainRecordId = "open-again-record-id";
+static const std::string OpenAgainRecordId = "open-again-record-id";
 
 class OpenedSecondTimeContinuation : public OpenContinuation {
  public:
   explicit OpenedSecondTimeContinuation(TestManager* aTestManager,
-                                        const string& aTestID)
+                                        const std::string& aTestID)
       : mTestmanager(aTestManager), mTestID(aTestID) {}
 
   void operator()(bool aSuccess) override {
     if (!aSuccess) {
       FakeDecryptor::Message(
           "FAIL OpenSecondTimeContinuation should not be able to re-open "
           "record.");
     }
     // Succeeded, open should have failed.
     mTestmanager->EndTest(mTestID);
   }
 
  private:
   TestManager* const mTestmanager;
-  const string mTestID;
+  const std::string mTestID;
 };
 
 class OpenedFirstTimeContinuation : public OpenContinuation {
  public:
-  OpenedFirstTimeContinuation(const string& aID, TestManager* aTestManager,
-                              const string& aTestID)
+  OpenedFirstTimeContinuation(const std::string& aID, TestManager* aTestManager,
+                              const std::string& aTestID)
       : mID(aID), mTestmanager(aTestManager), mTestID(aTestID) {}
 
   void operator()(bool aSuccess) override {
     if (!aSuccess) {
       FakeDecryptor::Message(
           "FAIL OpenAgainContinuation to open record initially.");
       mTestmanager->EndTest(mTestID);
       return;
     }
 
     auto cont = OpenedSecondTimeContinuation(mTestmanager, mTestID);
     OpenRecord(FakeDecryptor::sInstance->mHost, mID, cont);
   }
 
  private:
-  const string mID;
+  const std::string mID;
   TestManager* const mTestmanager;
-  const string mTestID;
+  const std::string mTestID;
 };
 
-static void DoTestStorage(const string& aPrefix, TestManager* aTestManager) {
+static void DoTestStorage(const std::string& aPrefix,
+                          TestManager* aTestManager) {
   MOZ_ASSERT(FakeDecryptor::sInstance->mHost,
              "FakeDecryptor::sInstance->mHost should not be null");
   // Basic I/O tests. We run three cases concurrently. The tests, like
   // CDMStorage run asynchronously. When they've all passed, we send
   // a message back to the parent process, or a failure message if not.
 
   // Test 1: Basic I/O test, and test that writing 0 bytes in a record
   // deletes record.
   //
   // Write data to truncate record, then
   // read data, verify that we read what we wrote, then
   // write 0 bytes to truncate record, then
   // read data, verify that 0 bytes was read
-  const string id1 = aPrefix + TruncateRecordId;
-  const string testID1 = aPrefix + "write-test-1";
+  const std::string id1 = aPrefix + TruncateRecordId;
+  const std::string testID1 = aPrefix + "write-test-1";
   aTestManager->BeginTest(testID1);
   auto cont1 = TruncateContinuation(id1, aTestManager, testID1);
   auto msg1 = "FAIL in TestStorage writing TruncateRecord.";
   WriteRecord(FakeDecryptor::sInstance->mHost, id1, TruncateRecordData,
               WriteRecordSuccessTask<TruncateContinuation>(id1, cont1),
               WriteRecordFailureTask(msg1, aTestManager, testID1));
 
   // Test 2: Test that overwriting a record with a shorter record truncates
   // the record to the shorter record.
   //
   // Write record, then
   // read and verify record, then
   // write a shorter record to same record.
   // read and verify
-  string id2 = aPrefix + "record1";
-  string record1 = "This is the first write to a record.";
-  string overwrite = "A shorter record";
-  const string testID2 = aPrefix + "write-test-2";
+  std::string id2 = aPrefix + "record1";
+  std::string record1 = "This is the first write to a record.";
+  std::string overwrite = "A shorter record";
+  const std::string testID2 = aPrefix + "write-test-2";
   aTestManager->BeginTest(testID2);
   auto task2 = VerifyAndOverwriteContinuation(id2, record1, overwrite,
                                               aTestManager, testID2);
   auto msg2 = "FAIL in TestStorage writing record1.";
   WriteRecord(
       FakeDecryptor::sInstance->mHost, id2, record1,
       WriteRecordSuccessTask<VerifyAndOverwriteContinuation>(id2, task2),
       WriteRecordFailureTask(msg2, aTestManager, testID2));
 
   // Test 3: Test that opening a record while it's already open fails.
   //
   // Open record1, then
   // open record1, should fail.
   // close record1
-  const string id3 = aPrefix + OpenAgainRecordId;
-  const string testID3 = aPrefix + "open-test-1";
+  const std::string id3 = aPrefix + OpenAgainRecordId;
+  const std::string testID3 = aPrefix + "open-test-1";
   aTestManager->BeginTest(testID3);
   auto task3 = OpenedFirstTimeContinuation(id3, aTestManager, testID3);
   OpenRecord(FakeDecryptor::sInstance->mHost, id3, task3);
 }
 
 void FakeDecryptor::TestStorage() {
   auto* testManager = new TestManager();
   // Main thread tests.
@@ -335,93 +338,93 @@ void FakeDecryptor::TestStorage() {
   DoTestStorage("mt2-", testManager);
 
   // Note: Once all tests finish, TestManager will dispatch "test-pass" message,
   // which ends the test for the parent.
 }
 
 class ReportWritten {
  public:
-  ReportWritten(const string& aRecordId, const string& aValue)
+  ReportWritten(const std::string& aRecordId, const std::string& aValue)
       : mRecordId(aRecordId), mValue(aValue) {}
   void operator()() {
     FakeDecryptor::Message("stored " + mRecordId + " " + mValue);
   }
 
-  const string mRecordId;
-  const string mValue;
+  const std::string mRecordId;
+  const std::string mValue;
 };
 
 class ReportReadStatusContinuation : public ReadContinuation {
  public:
-  explicit ReportReadStatusContinuation(const string& aRecordId)
+  explicit ReportReadStatusContinuation(const std::string& aRecordId)
       : mRecordId(aRecordId) {}
   void operator()(bool aSuccess, const uint8_t* aData,
                   uint32_t aDataSize) override {
     if (!aSuccess) {
       FakeDecryptor::Message("retrieve " + mRecordId + " failed");
     } else {
-      stringstream ss;
+      std::stringstream ss;
       ss << aDataSize;
-      string len;
+      std::string len;
       ss >> len;
       FakeDecryptor::Message("retrieve " + mRecordId + " succeeded (length " +
                              len + " bytes)");
     }
   }
-  string mRecordId;
+  std::string mRecordId;
 };
 
 class ReportReadRecordContinuation : public ReadContinuation {
  public:
-  explicit ReportReadRecordContinuation(const string& aRecordId)
+  explicit ReportReadRecordContinuation(const std::string& aRecordId)
       : mRecordId(aRecordId) {}
   void operator()(bool aSuccess, const uint8_t* aData,
                   uint32_t aDataSize) override {
     if (!aSuccess) {
       FakeDecryptor::Message("retrieved " + mRecordId + " failed");
     } else {
       FakeDecryptor::Message(
           "retrieved " + mRecordId + " " +
-          string(reinterpret_cast<const char*>(aData), aDataSize));
+          std::string(reinterpret_cast<const char*>(aData), aDataSize));
     }
   }
-  string mRecordId;
+  std::string mRecordId;
 };
 
 enum ShutdownMode { ShutdownNormal, ShutdownTimeout, ShutdownStoreToken };
 
 static ShutdownMode sShutdownMode = ShutdownNormal;
-static string sShutdownToken;
+static std::string sShutdownToken;
 
 void FakeDecryptor::UpdateSession(uint32_t aPromiseId, const char* aSessionId,
                                   uint32_t aSessionIdLength,
                                   const uint8_t* aResponse,
                                   uint32_t aResponseSize) {
   MOZ_ASSERT(FakeDecryptor::sInstance->mHost,
              "FakeDecryptor::sInstance->mHost should not be null");
   std::string response((const char*)aResponse,
                        (const char*)(aResponse) + aResponseSize);
   std::vector<std::string> tokens = Tokenize(response);
-  const string& task = tokens[0];
+  const std::string& task = tokens[0];
   if (task == "test-storage") {
     TestStorage();
   } else if (task == "store") {
     // send "stored record" message on complete.
-    const string& id = tokens[1];
-    const string& value = tokens[2];
+    const std::string& id = tokens[1];
+    const std::string& value = tokens[2];
     WriteRecord(FakeDecryptor::sInstance->mHost, id, value,
                 ReportWritten(id, value),
                 WriteRecordFailureTask("FAIL in writing record."));
   } else if (task == "retrieve") {
-    const string& id = tokens[1];
+    const std::string& id = tokens[1];
     ReadRecord(FakeDecryptor::sInstance->mHost, id,
                ReportReadStatusContinuation(id));
   } else if (task == "shutdown-mode") {
-    const string& mode = tokens[1];
+    const std::string& mode = tokens[1];
     if (mode == "timeout") {
       sShutdownMode = ShutdownTimeout;
     } else if (mode == "token") {
       sShutdownMode = ShutdownStoreToken;
       sShutdownToken = tokens[2];
       Message("shutdown-token received " + sShutdownToken);
     }
   } else if (task == "retrieve-shutdown-token") {

--- a/dom/media/fake-cdm/cdm-test-storage.cpp
+++ b/dom/media/fake-cdm/cdm-test-storage.cpp
@@ -5,22 +5,21 @@
 
 #include "cdm-test-storage.h"
 #include <vector>
 
 #include "mozilla/Assertions.h"
 #include "mozilla/Attributes.h"
 
 using namespace cdm;
-using namespace std;
 
 class WriteRecordClient : public FileIOClient {
  public:
-  WriteRecordClient(function<void()>&& aOnSuccess,
-                    function<void()>&& aOnFailure, const uint8_t* aData,
+  WriteRecordClient(std::function<void()>&& aOnSuccess,
+                    std::function<void()>&& aOnFailure, const uint8_t* aData,
                     uint32_t aDataSize)
       : mOnSuccess(move(aOnSuccess)), mOnFailure(move(aOnFailure)) {
     mData.insert(mData.end(), aData, aData + aDataSize);
   }
 
   void OnOpenComplete(Status aStatus) override {
     // If we hit an error, fail.
     if (aStatus != Status::kSuccess) {
@@ -30,17 +29,17 @@ class WriteRecordClient : public FileIOC
     }
   }
 
   void OnReadComplete(Status aStatus, const uint8_t* aData,
                       uint32_t aDataSize) override {}
 
   void OnWriteComplete(Status aStatus) override { Done(aStatus); }
 
-  void Do(const string& aName, Host_10* aHost) {
+  void Do(const std::string& aName, Host_10* aHost) {
     // Initialize the FileIO.
     mFileIO = aHost->CreateFileIO(this);
     mFileIO->Open(aName.c_str(), aName.size());
   }
 
  private:
   void Done(cdm::FileIOClient::Status aStatus) {
     // Note: Call Close() before running continuation, in case the
@@ -58,41 +57,42 @@ class WriteRecordClient : public FileIOC
     } else {
       mOnFailure();
     }
 
     delete this;
   }
 
   FileIO* mFileIO = nullptr;
-  function<void()> mOnSuccess;
-  function<void()> mOnFailure;
+  std::function<void()> mOnSuccess;
+  std::function<void()> mOnFailure;
   std::vector<uint8_t> mData;
 };
 
 void WriteRecord(Host_10* aHost, const std::string& aRecordName,
                  const uint8_t* aData, uint32_t aNumBytes,
-                 function<void()>&& aOnSuccess, function<void()>&& aOnFailure) {
+                 std::function<void()>&& aOnSuccess,
+                 std::function<void()>&& aOnFailure) {
   // client will be delete in WriteRecordClient::Done
   WriteRecordClient* client = new WriteRecordClient(
       move(aOnSuccess), move(aOnFailure), aData, aNumBytes);
   client->Do(aRecordName, aHost);
 }
 
 void WriteRecord(Host_10* aHost, const std::string& aRecordName,
-                 const std::string& aData, function<void()>&& aOnSuccess,
-                 function<void()>&& aOnFailure) {
+                 const std::string& aData, std::function<void()>&& aOnSuccess,
+                 std::function<void()>&& aOnFailure) {
   return WriteRecord(aHost, aRecordName, (const uint8_t*)aData.c_str(),
                      aData.size(), move(aOnSuccess), move(aOnFailure));
 }
 
 class ReadRecordClient : public FileIOClient {
  public:
   explicit ReadRecordClient(
-      function<void(bool, const uint8_t*, uint32_t)>&& aOnReadComplete)
+      std::function<void(bool, const uint8_t*, uint32_t)>&& aOnReadComplete)
       : mOnReadComplete(move(aOnReadComplete)) {}
 
   void OnOpenComplete(Status aStatus) override {
     auto err = aStatus;
     if (aStatus != Status::kSuccess) {
       Done(err, reinterpret_cast<const uint8_t*>(""), 0);
     } else {
       mFileIO->Read();
@@ -101,17 +101,17 @@ class ReadRecordClient : public FileIOCl
 
   void OnReadComplete(Status aStatus, const uint8_t* aData,
                       uint32_t aDataSize) override {
     Done(aStatus, aData, aDataSize);
   }
 
   void OnWriteComplete(Status aStatus) override {}
 
-  void Do(const string& aName, Host_10* aHost) {
+  void Do(const std::string& aName, Host_10* aHost) {
     mFileIO = aHost->CreateFileIO(this);
     mFileIO->Open(aName.c_str(), aName.size());
   }
 
  private:
   void Done(cdm::FileIOClient::Status aStatus, const uint8_t* aData,
             uint32_t aDataSize) {
     // Note: Call Close() before running continuation, in case the
@@ -129,40 +129,40 @@ class ReadRecordClient : public FileIOCl
     } else {
       mOnReadComplete(false, reinterpret_cast<const uint8_t*>(""), 0);
     }
 
     delete this;
   }
 
   FileIO* mFileIO = nullptr;
-  function<void(bool, const uint8_t*, uint32_t)> mOnReadComplete;
+  std::function<void(bool, const uint8_t*, uint32_t)> mOnReadComplete;
 };
 
 void ReadRecord(
     Host_10* aHost, const std::string& aRecordName,
-    function<void(bool, const uint8_t*, uint32_t)>&& aOnReadComplete) {
+    std::function<void(bool, const uint8_t*, uint32_t)>&& aOnReadComplete) {
   // client will be delete in ReadRecordClient::Done
   ReadRecordClient* client = new ReadRecordClient(move(aOnReadComplete));
   client->Do(aRecordName, aHost);
 }
 
 class OpenRecordClient : public FileIOClient {
  public:
-  explicit OpenRecordClient(function<void(bool)>&& aOpenComplete)
+  explicit OpenRecordClient(std::function<void(bool)>&& aOpenComplete)
       : mOpenComplete(move(aOpenComplete)) {}
 
   void OnOpenComplete(Status aStatus) override { Done(aStatus); }
 
   void OnReadComplete(Status aStatus, const uint8_t* aData,
                       uint32_t aDataSize) override {}
 
   void OnWriteComplete(Status aStatus) override {}
 
-  void Do(const string& aName, Host_10* aHost) {
+  void Do(const std::string& aName, Host_10* aHost) {
     // Initialize the FileIO.
     mFileIO = aHost->CreateFileIO(this);
     mFileIO->Open(aName.c_str(), aName.size());
   }
 
  private:
   void Done(cdm::FileIOClient::Status aStatus) {
     // Note: Call Close() before running continuation, in case the
@@ -180,18 +180,18 @@ class OpenRecordClient : public FileIOCl
     } else {
       mOpenComplete(false);
     }
 
     delete this;
   }
 
   FileIO* mFileIO = nullptr;
-  function<void(bool)> mOpenComplete;
+  std::function<void(bool)> mOpenComplete;
   ;
 };
 
 void OpenRecord(Host_10* aHost, const std::string& aRecordName,
-                function<void(bool)>&& aOpenComplete) {
+                std::function<void(bool)>&& aOpenComplete) {
   // client will be delete in OpenRecordClient::Done
   OpenRecordClient* client = new OpenRecordClient(move(aOpenComplete));
   client->Do(aRecordName, aHost);
 }

--- a/dom/media/gtest/TestGMPCrossOrigin.cpp
+++ b/dom/media/gtest/TestGMPCrossOrigin.cpp
@@ -11,18 +11,16 @@
 #include "GMPVideoDecoderProxy.h"
 #include "GMPVideoEncoderProxy.h"
 #include "GMPServiceParent.h"
 #include "nsAppDirectoryServiceDefs.h"
 #include "mozilla/Atomics.h"
 #include "mozilla/DebugOnly.h"
 #include "nsThreadUtils.h"
 
-using namespace std;
-
 using namespace mozilla;
 using namespace mozilla::gmp;
 
 struct GMPTestRunner {
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GMPTestRunner)
 
   GMPTestRunner() {}
   void DoTest(void (GMPTestRunner::*aTestMethod)(GMPTestMonitor&));

--- a/dom/media/gtest/TestGMPUtils.cpp
+++ b/dom/media/gtest/TestGMPUtils.cpp
@@ -6,17 +6,16 @@
 
 #include "gtest/gtest.h"
 #include "GMPUtils.h"
 #include "nsString.h"
 
 #include <string>
 #include <vector>
 
-using namespace std;
 using namespace mozilla;
 
 void TestSplitAt(const char* aInput, const char* aDelims,
                  size_t aNumExpectedTokens, const char* aExpectedTokens[]) {
   nsCString input(aInput);
   nsTArray<nsCString> tokens;
   SplitAt(aDelims, input, tokens);
   EXPECT_EQ(tokens.Length(), aNumExpectedTokens)
@@ -55,17 +54,17 @@ TEST(GeckoMediaPlugins, TestSplitAt)
     TestSplitAt(input, delims, MOZ_ARRAY_LENGTH(tokens), tokens);
   }
 }
 
 TEST(GeckoMediaPlugins, ToHexString)
 {
   struct Test {
     nsTArray<uint8_t> bytes;
-    string hex;
+    std::string hex;
   };
 
   static const Test tests[] = {
       {{0x00, 0x00}, "0000"},
       {{0xff, 0xff}, "ffff"},
       {{0xff, 0x00}, "ff00"},
       {{0x00, 0xff}, "00ff"},
       {{0xf0, 0x10}, "f010"},