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

Source/core/xml/parser/XMLDocumentParser.cpp

 /*
  * Copyright (C) 2000 Peter Kelly (pmk@post.com)
  * Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008 Holger Hans Peter Freyther
  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 54 matching lines @@
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/StringExtras.h"
 #include "wtf/TemporaryChange.h"
 #include "wtf/Threading.h"
 #include "wtf/Vector.h"
 #include "wtf/unicode/UTF8.h"
 
-using namespace std;
-
 namespace WebCore {
 
 using namespace HTMLNames;
 
 // FIXME: HTMLConstructionSite has a limit of 512, should these match?
 static const unsigned maxXMLTreeDepth = 5000;
 
-static inline String toString(const xmlChar* string, size_t length)
+static inline String toString(const xmlChar* string, std::size_t length)
 {
     return String::fromUTF8(reinterpret_cast<const char*>(string), length);
 }
 
 static inline String toString(const xmlChar* string)
 {
     return String::fromUTF8(reinterpret_cast<const char*>(string));
 }
 
-static inline AtomicString toAtomicString(const xmlChar* string, size_t length)
+static inline AtomicString toAtomicString(const xmlChar* string, std::size_t length)
 {
     return AtomicString::fromUTF8(reinterpret_cast<const char*>(string), length);
 }
 
 static inline AtomicString toAtomicString(const xmlChar* string)
 {
     return AtomicString::fromUTF8(reinterpret_cast<const char*>(string));
 }
 
 static inline bool hasNoStyleInformation(Document* document)
@@ skipping 221 matching lines @@
 {
 #if !ENABLE(OILPAN)
     if (m_currentNode && m_currentNode != document())
         m_currentNode->deref();
 #endif
     m_currentNode = nullptr;
     m_leafTextNode = nullptr;
 
     if (m_currentNodeStack.size()) { // Aborted parsing.
 #if !ENABLE(OILPAN)
-        for (size_t i = m_currentNodeStack.size() - 1; i != 0; --i)
+        for (std::size_t i = m_currentNodeStack.size() - 1; i != 0; --i)
             m_currentNodeStack[i]->deref();
         if (m_currentNodeStack[0] && m_currentNodeStack[0] != document())
             m_currentNodeStack[0]->deref();
 #endif
         m_currentNodeStack.clear();
     }
 }
 
 void XMLDocumentParser::insert(const SegmentedString&)
 {
@@ skipping 955 matching lines @@
     static xmlEntity entity;
     if (!entity.type) {
         entity.type = XML_ENTITY_DECL;
         entity.orig = sharedXHTMLEntityResult;
         entity.content = sharedXHTMLEntityResult;
         entity.etype = XML_INTERNAL_PREDEFINED_ENTITY;
     }
     return &entity;
 }
 
-static size_t convertUTF16EntityToUTF8(const UChar* utf16Entity, size_t numberOfCodeUnits, char* target, size_t targetSize)
+static std::size_t convertUTF16EntityToUTF8(const UChar* utf16Entity, std::size_t numberOfCodeUnits, char* target, std::size_t targetSize)
 {
     const char* originalTarget = target;
     WTF::Unicode::ConversionResult conversionResult = WTF::Unicode::convertUTF16ToUTF8(&utf16Entity,
         utf16Entity + numberOfCodeUnits, &target, target + targetSize);
     if (conversionResult != WTF::Unicode::conversionOK)
         return 0;
 
     // Even though we must pass the length, libxml expects the entity string to be null terminated.
     ASSERT(target > originalTarget + 1);
     *target = '\0';
     return target - originalTarget;
 }
 
 static xmlEntityPtr getXHTMLEntity(const xmlChar* name)
 {
     UChar utf16DecodedEntity[4];
-    size_t numberOfCodeUnits = decodeNamedEntityToUCharArray(reinterpret_cast<const char*>(name), utf16DecodedEntity);
+    std::size_t numberOfCodeUnits = decodeNamedEntityToUCharArray(reinterpret_cast<const char*>(name), utf16DecodedEntity);
     if (!numberOfCodeUnits)
         return 0;
 
     ASSERT(numberOfCodeUnits <= 4);
-    size_t entityLengthInUTF8 = convertUTF16EntityToUTF8(utf16DecodedEntity, numberOfCodeUnits,
+    std::size_t entityLengthInUTF8 = convertUTF16EntityToUTF8(utf16DecodedEntity, numberOfCodeUnits,
         reinterpret_cast<char*>(sharedXHTMLEntityResult), WTF_ARRAY_LENGTH(sharedXHTMLEntityResult));
     if (!entityLengthInUTF8)
         return 0;
 
     xmlEntityPtr entity = sharedXHTMLEntity();
     entity->length = entityLengthInUTF8;
     entity->name = name;
     return entity;
 }
 
@@ skipping 273 matching lines @@
     sax.initialized = XML_SAX2_MAGIC;
     RefPtr<XMLParserContext> parser = XMLParserContext::createStringParser(&sax, &state);
     String parseString = "<?xml version=\"1.0\"?><attrs " + string + " />";
     parseChunk(parser->context(), parseString);
     finishParsing(parser->context());
     attrsOK = state.gotAttributes;
     return state.attributes;
 }
 
 } // namespace WebCore