Removing "using" declarations that import names in the C++ Standard library.

Source/web/WebDevToolsAgentImpl.cpp

 /*
  * Copyright (C) 2010-2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 57 matching lines @@
 #include "public/web/WebViewClient.h"
 #include "web/WebInputEventConversion.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebViewImpl.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/MathExtras.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/text/WTFString.h"
 
 using namespace WebCore;
-using namespace std;
 
 namespace OverlayZOrders {
 // Use 99 as a big z-order number so that highlight is above other overlays.
 static const int highlight = 99;
 }
 
 namespace blink {
 
 class ClientMessageLoopAdapter : public PageScriptDebugServer::ClientMessageLoop {
 public:
@@ skipping 358 matching lines @@
     public:
         CountingVisitor() : m_totalObjectsCount(0)
         {
         }
 
         virtual bool visitObject(const void* ptr)
         {
             ++m_totalObjectsCount;
             return true;
         }
-        size_t totalObjectsCount() const
+        std::size_t totalObjectsCount() const
         {
             return m_totalObjectsCount;
         }
 
     private:
-        size_t m_totalObjectsCount;
+        std::size_t m_totalObjectsCount;
     };
 
     CountingVisitor counter;
     m_client->visitAllocatedObjects(&counter);
 
     class PointerCollector : public WebDevToolsAgentClient::AllocatedObjectVisitor {
     public:
-        explicit PointerCollector(size_t maxObjectsCount)
+        explicit PointerCollector(std::size_t maxObjectsCount)
             : m_maxObjectsCount(maxObjectsCount)
             , m_index(0)
             , m_success(true)
             , m_pointers(new const void*[maxObjectsCount])
         {
         }
         virtual ~PointerCollector()
         {
             delete[] m_pointers;
         }
         virtual bool visitObject(const void* ptr)
         {
             if (m_index == m_maxObjectsCount) {
                 m_success = false;
                 return false;
             }
             m_pointers[m_index++] = ptr;
             return true;
         }
 
         bool success() const { return m_success; }
 
         void copyTo(HashSet<const void*>& set)
         {
-            for (size_t i = 0; i < m_index; i++)
+            for (std::size_t i = 0; i < m_index; i++)
                 set.add(m_pointers[i]);
         }
 
     private:
-        const size_t m_maxObjectsCount;
-        size_t m_index;
+        const std::size_t m_maxObjectsCount;
+        std::size_t m_index;
         bool m_success;
         const void** m_pointers;
     };
 
     // Double size to allow room for all objects that may have been allocated
     // since we counted them.
-    size_t estimatedMaxObjectsCount = counter.totalObjectsCount() * 2;
+    std::size_t estimatedMaxObjectsCount = counter.totalObjectsCount() * 2;
     while (true) {
         PointerCollector collector(estimatedMaxObjectsCount);
         m_client->visitAllocatedObjects(&collector);
         if (collector.success()) {
             collector.copyTo(set);
             break;
         }
         estimatedMaxObjectsCount *= 2;
     }
 }
 
-void WebDevToolsAgentImpl::dumpUncountedAllocatedObjects(const HashMap<const void*, size_t>& map)
+void WebDevToolsAgentImpl::dumpUncountedAllocatedObjects(const HashMap<const void*, std::size_t>& map)
 {
     class InstrumentedObjectSizeProvider : public WebDevToolsAgentClient::InstrumentedObjectSizeProvider {
     public:
-        InstrumentedObjectSizeProvider(const HashMap<const void*, size_t>& map) : m_map(map) { }
-        virtual size_t objectSize(const void* ptr) const
+        InstrumentedObjectSizeProvider(const HashMap<const void*, std::size_t>& map) : m_map(map) { }
+        virtual std::size_t objectSize(const void* ptr) const
         {
-            HashMap<const void*, size_t>::const_iterator i = m_map.find(ptr);
+            HashMap<const void*, std::size_t>::const_iterator i = m_map.find(ptr);
             return i == m_map.end() ? 0 : i->value;
         }
 
     private:
-        const HashMap<const void*, size_t>& m_map;
+        const HashMap<const void*, std::size_t>& m_map;
     };
 
     InstrumentedObjectSizeProvider provider(map);
     m_client->dumpUncountedAllocatedObjects(&provider);
 }
 
 void WebDevToolsAgentImpl::setTraceEventCallback(const String& categoryFilter, TraceEventCallback callback)
 {
     m_client->setTraceEventCallback(categoryFilter, callback);
 }
@@ skipping 128 matching lines @@
 {
     InspectorController* ic = inspectorController();
     ic->evaluateForTestInFrontend(callId, script);
 }
 
 void WebDevToolsAgentImpl::flushPendingFrontendMessages()
 {
     InspectorController* ic = inspectorController();
     ic->flushPendingFrontendMessages();
 
-    for (size_t i = 0; i < m_frontendMessageQueue.size(); ++i)
+    for (std::size_t i = 0; i < m_frontendMessageQueue.size(); ++i)
         m_client->sendMessageToInspectorFrontend(m_frontendMessageQueue[i]->toJSONString());
     m_frontendMessageQueue.clear();
 }
 
 void WebDevToolsAgentImpl::willProcessTask()
 {
     if (!m_attached)
         return;
     if (InspectorController* ic = inspectorController())
         ic->willProcessTask();
@@ skipping 29 matching lines @@
         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_removeBreakpointCmd)
         || commandName == InspectorBackendDispatcher::commandName(InspectorBackendDispatcher::kDebugger_setBreakpointsActiveCmd);
 }
 
 void WebDevToolsAgent::processPendingMessages()
 {
     PageScriptDebugServer::shared().runPendingTasks();
 }
 
 } // namespace blink