Removing "using" declarations that import names in the C++ Standard library.(Source/platform/[m* - …

Source/platform/scheduler/SchedulerTest.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "platform/scheduler/Scheduler.h"
 
 #include "platform/TestingPlatformSupport.h"
 #include "platform/TraceLocation.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebThread.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <string>
 #include <vector>
 
 using blink::Scheduler;
-using namespace std;
 
 namespace {
 
 class TestMainThread : public blink::WebThread {
 public:
     // blink::WebThread implementation.
     virtual void postTask(Task* task) OVERRIDE
     {
         m_pendingTasks.append(adoptPtr(task));
     }
@@ skipping 100 matching lines @@
     ~SchedulerTest()
     {
         Scheduler::shutdown();
     }
 
     void runPendingTasks()
     {
         m_platformSupport.runPendingTasks();
     }
 
-    void appendToVector(string value)
+    void appendToVector(std::string value)
     {
         m_order.push_back(value);
     }
 
     void appendToVectorReentrantTask()
     {
         m_reentrantOrder.push_back(m_reentrantCount++);
 
         if (m_reentrantCount > m_maxRecursion)
             return;
@@ skipping 14 matching lines @@
         m_reentrantOrder.push_back(m_reentrantCount++);
 
         if (m_reentrantCount > m_maxRecursion)
             return;
         m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVectorReentrantCompositorTask, this));
     }
 
 protected:
     SchedulerTestingPlatformSupport m_platformSupport;
     Scheduler* m_scheduler;
-    std::vector<string> m_order;
+    std::vector<std::string> m_order;
     std::vector<int> m_reentrantOrder;
     int m_reentrantCount;
     int m_maxRecursion;
 };
 
 void orderedTestTask(int value, int* result)
 {
     *result = (*result << 4) | value;
 }
 
@@ skipping 60 matching lines @@
     m_scheduler->postIdleTask(FROM_HERE, WTF::bind<double>(&idleTestTask, 1, &result));
     m_scheduler->postIdleTask(FROM_HERE, WTF::bind<double>(&idleTestTask, 1, &result));
     m_scheduler->postIdleTask(FROM_HERE, WTF::bind<double>(&idleTestTask, 1, &result));
     m_scheduler->postIdleTask(FROM_HERE, WTF::bind<double>(&idleTestTask, 1, &result));
     runPendingTasks();
     EXPECT_EQ(4, result);
 }
 
 TEST_F(SchedulerTest, TestTaskPrioritization)
 {
-    m_scheduler->postTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, string("L1")));
-    m_scheduler->postTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, string("L2")));
-    m_scheduler->postInputTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, string("I1")));
-    m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, string("C1")));
-    m_scheduler->postInputTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, string("I2")));
-    m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, string("C2")));
+    m_scheduler->postTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("L1")));
+    m_scheduler->postTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("L2")));
+    m_scheduler->postInputTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("I1")));
+    m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("C1")));
+    m_scheduler->postInputTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("I2")));
+    m_scheduler->postCompositorTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVector, this, std::string("C2")));
 
     runPendingTasks();
     EXPECT_THAT(m_order, testing::ElementsAre(
-        string("I1"), string("C1"), string("I2"), string("C2"), string("L1"), string("L2")));
+        std::string("I1"), std::string("C1"), std::string("I2"), std::string("C2"), std::string("L1"), std::string("L2")));
 }
 
 TEST_F(SchedulerTest, TestRentrantTask)
 {
     m_scheduler->postTask(FROM_HERE, WTF::bind(&SchedulerTest::appendToVectorReentrantTask, this));
     runPendingTasks();
 
     EXPECT_THAT(m_reentrantOrder, testing::ElementsAre(0, 1, 2, 3, 4));
 }
 
@@ skipping 46 matching lines @@
 {
     s_shouldContinue = true;
     m_scheduler->postInputTask(FROM_HERE, WTF::bind(&reentrantCompositorTask, m_scheduler));
     m_scheduler->postTask(FROM_HERE, WTF::bind(&stopReentrantTask));
 
     // If starvation occurs then this will never exit.
     runPendingTasks();
 }
 
 } // namespace