Bug 1577934 - Remove using namespace std from dom/media audio tests r=gerald
authorEric Rahm <erahm@mozilla.com>
Sun, 01 Sep 2019 06:47:26 +0000
changeset 554818 e714dd56f2de11115529a26112a4013a4b2726af
parent 554817 8867e44d49793d8af6b514089cf4b5ebea446985
child 554819 10f791c3a57f54869b1afeb237dbc544f74f4591
push id2165
push userffxbld-merge
push dateMon, 14 Oct 2019 16:30:58 +0000
treeherdermozilla-release@0eae18af659f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersgerald
bugs1577934
milestone70.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1577934 - Remove using namespace std from dom/media audio tests r=gerald Differential Revision: https://phabricator.services.mozilla.com/D44290
dom/media/fake-cdm/cdm-test-decryptor.cpp
dom/media/fake-cdm/cdm-test-storage.cpp
dom/media/gtest/TestGMPCrossOrigin.cpp
dom/media/gtest/TestGMPUtils.cpp
--- 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"},