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

Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 78 matching lines @@
 #include "platform/Partitions.h"
 #include "platform/TraceEvent.h"
 #include "platform/TracedValue.h"
 #include "wtf/HashSet.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/RefCountedLeakCounter.h"
 #include "wtf/Vector.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 
-using namespace std;
-
 namespace WebCore {
 
 using namespace HTMLNames;
 
 #if !ENABLE(OILPAN)
-void* Node::operator new(size_t size)
+void* Node::operator new(std::size_t size)
 {
     ASSERT(isMainThread());
     return partitionAlloc(Partitions::getObjectModelPartition(), size);
 }
 
 void Node::operator delete(void* ptr)
 {
     ASSERT(isMainThread());
     partitionFree(ptr);
 }
 #endif
 
 #if DUMP_NODE_STATISTICS
 static HashSet<Node*>& liveNodeSet()
 {
     DEFINE_STATIC_LOCAL(HashSet<Node*>, s_liveNodeSet, ());
     return s_liveNodeSet;
 }
 #endif
 
 void Node::dumpStatistics()
 {
 #if DUMP_NODE_STATISTICS
-    size_t nodesWithRareData = 0;
+    std::size_t nodesWithRareData = 0;
 
-    size_t elementNodes = 0;
-    size_t attrNodes = 0;
-    size_t textNodes = 0;
-    size_t cdataNodes = 0;
-    size_t commentNodes = 0;
-    size_t piNodes = 0;
-    size_t documentNodes = 0;
-    size_t docTypeNodes = 0;
-    size_t fragmentNodes = 0;
-    size_t shadowRootNodes = 0;
+    std::size_t elementNodes = 0;
+    std::size_t attrNodes = 0;
+    std::size_t textNodes = 0;
+    std::size_t cdataNodes = 0;
+    std::size_t commentNodes = 0;
+    std::size_t piNodes = 0;
+    std::size_t documentNodes = 0;
+    std::size_t docTypeNodes = 0;
+    std::size_t fragmentNodes = 0;
+    std::size_t shadowRootNodes = 0;
 
-    HashMap<String, size_t> perTagCount;
+    HashMap<String, std::size_t> perTagCount;
 
-    size_t attributes = 0;
-    size_t elementsWithAttributeStorage = 0;
-    size_t elementsWithRareData = 0;
-    size_t elementsWithNamedNodeMap = 0;
+    std::size_t attributes = 0;
+    std::size_t elementsWithAttributeStorage = 0;
+    std::size_t elementsWithRareData = 0;
+    std::size_t elementsWithNamedNodeMap = 0;
 
     for (HashSet<Node*>::iterator it = liveNodeSet().begin(); it != liveNodeSet().end(); ++it) {
         Node* node = *it;
 
         if (node->hasRareData()) {
             ++nodesWithRareData;
             if (node->isElementNode()) {
                 ++elementsWithRareData;
                 if (toElement(node)->hasNamedNodeMap())
                     ++elementsWithNamedNodeMap;
             }
         }
 
         switch (node->nodeType()) {
             case ELEMENT_NODE: {
                 ++elementNodes;
 
                 // Tag stats
                 Element* element = toElement(node);
-                HashMap<String, size_t>::AddResult result = perTagCount.add(element->tagName(), 1);
+                HashMap<String, std::size_t>::AddResult result = perTagCount.add(element->tagName(), 1);
                 if (!result.isNewEntry)
                     result.storedValue->value++;
 
                 if (const ElementData* elementData = element->elementData()) {
                     attributes += elementData->length();
                     ++elementsWithAttributeStorage;
                 }
                 break;
             }
             case ATTRIBUTE_NODE: {
@@ skipping 43 matching lines @@
     printf("  Number of Text nodes: %zu\n", textNodes);
     printf("  Number of CDATASection nodes: %zu\n", cdataNodes);
     printf("  Number of Comment nodes: %zu\n", commentNodes);
     printf("  Number of ProcessingInstruction nodes: %zu\n", piNodes);
     printf("  Number of Document nodes: %zu\n", documentNodes);
     printf("  Number of DocumentType nodes: %zu\n", docTypeNodes);
     printf("  Number of DocumentFragment nodes: %zu\n", fragmentNodes);
     printf("  Number of ShadowRoot nodes: %zu\n", shadowRootNodes);
 
     printf("Element tag name distibution:\n");
-    for (HashMap<String, size_t>::iterator it = perTagCount.begin(); it != perTagCount.end(); ++it)
+    for (HashMap<String, std::size_t>::iterator it = perTagCount.begin(); it != perTagCount.end(); ++it)
         printf("  Number of <%s> tags: %zu\n", it->key.utf8().data(), it->value);
 
     printf("Attributes:\n");
     printf("  Number of Attributes (non-Node and Node): %zu [%zu]\n", attributes, sizeof(Attribute));
     printf("  Number of Elements with attribute storage: %zu [%zu]\n", elementsWithAttributeStorage, sizeof(ElementData));
     printf("  Number of Elements with RareData: %zu\n", elementsWithRareData);
     printf("  Number of Elements with NamedNodeMap: %zu [%zu]\n", elementsWithNamedNodeMap, sizeof(NamedNodeMap));
 #endif
 }
 
@@ skipping 382 matching lines @@
     // is non-empty, since this is a faster check and almost always returns true.
     RenderBoxModelObject* box = renderBoxModelObject();
     if (!box)
         return false;
     if (!box->borderBoundingBox().isEmpty())
         return true;
 
     Vector<IntRect> rects;
     FloatPoint absPos = renderer()->localToAbsolute();
     renderer()->absoluteRects(rects, flooredLayoutPoint(absPos));
-    size_t n = rects.size();
-    for (size_t i = 0; i < n; ++i)
+    std::size_t n = rects.size();
+    for (std::size_t i = 0; i < n; ++i)
         if (!rects[i].isEmpty())
             return true;
 
     return false;
 }
 
 #ifndef NDEBUG
 inline static ShadowRoot* oldestShadowRootFor(const Node* node)
 {
     if (!node->isElementNode())
@@ skipping 50 matching lines @@
 }
 
 namespace {
 
 PassRefPtr<JSONArray> jsStackAsJSONArray()
 {
     RefPtr<JSONArray> jsonArray = JSONArray::create();
     RefPtr<ScriptCallStack> stack = createScriptCallStack(10);
     if (!stack)
         return jsonArray.release();
-    for (size_t i = 0; i < stack->size(); i++)
+    for (std::size_t i = 0; i < stack->size(); i++)
         jsonArray->pushString(stack->at(i).functionName());
     return jsonArray.release();
 }
 
 PassRefPtr<JSONObject> jsonObjectForStyleInvalidation(unsigned nodeCount, const Node* rootNode)
 {
     RefPtr<JSONObject> jsonObject = JSONObject::create();
     jsonObject->setNumber("node_count", nodeCount);
     jsonObject->setString("root_node", rootNode->debugName());
     jsonObject->setArray("js_stack", jsStackAsJSONArray());
@@ skipping 897 matching lines @@
 
     // If the two elements don't have a common root, they're not in the same tree.
     if (chain1[index1 - 1] != chain2[index2 - 1]) {
         unsigned short direction = (this > otherNode) ? DOCUMENT_POSITION_PRECEDING : DOCUMENT_POSITION_FOLLOWING;
         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | direction;
     }
 
     unsigned connection = start1->treeScope() != start2->treeScope() ? DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC : 0;
 
     // Walk the two chains backwards and look for the first difference.
-    for (unsigned i = min(index1, index2); i; --i) {
+    for (unsigned i = std::min(index1, index2); i; --i) {
         const Node* child1 = chain1[--index1];
         const Node* child2 = chain2[--index2];
         if (child1 != child2) {
             // If one of the children is an attribute, it wins.
             if (child1->nodeType() == ATTRIBUTE_NODE)
                 return DOCUMENT_POSITION_FOLLOWING | connection;
             if (child2->nodeType() == ATTRIBUTE_NODE)
                 return DOCUMENT_POSITION_PRECEDING | connection;
 
             // If one of the children is a shadow root,
@@ skipping 65 matching lines @@
     name.append(nodeName());
 
     if (hasID()) {
         name.appendLiteral(" id=\'");
         name.append(toElement(this)->getIdAttribute());
         name.append('\'');
     }
 
     if (hasClass()) {
         name.appendLiteral(" class=\'");
-        for (size_t i = 0; i < toElement(this)->classNames().size(); ++i) {
+        for (std::size_t i = 0; i < toElement(this)->classNames().size(); ++i) {
             if (i > 0)
                 name.append(' ');
             name.append(toElement(this)->classNames()[i]);
         }
         name.append('\'');
     }
 
     return name.toString();
 }
 
@@ skipping 228 matching lines @@
         }
     }
     if (oldDocument.frameHost() != document().frameHost()) {
         if (oldDocument.frameHost())
             oldDocument.frameHost()->eventHandlerRegistry().didMoveOutOfFrameHost(*this);
         if (document().frameHost())
             document().frameHost()->eventHandlerRegistry().didMoveIntoFrameHost(*this);
     }
 
     if (WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration> >* registry = mutationObserverRegistry()) {
-        for (size_t i = 0; i < registry->size(); ++i) {
+        for (std::size_t i = 0; i < registry->size(); ++i) {
             document().addMutationObserverTypes(registry->at(i)->mutationTypes());
         }
     }
 
     if (WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration> >* transientRegistry = transientMutationObserverRegistry()) {
         for (WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration> >::iterator iter = transientRegistry->begin(); iter != transientRegistry->end(); ++iter) {
             document().addMutationObserverTypes((*iter)->mutationTypes());
         }
     }
 }
@@ skipping 135 matching lines @@
     for (Node* node = parentNode(); node; node = node->parentNode()) {
         collectMatchingObserversForMutation(observers, node->mutationObserverRegistry(), *this, type, attributeName);
         collectMatchingObserversForMutation(observers, node->transientMutationObserverRegistry(), *this, type, attributeName);
     }
 }
 
 void Node::registerMutationObserver(MutationObserver& observer, MutationObserverOptions options, const HashSet<AtomicString>& attributeFilter)
 {
     MutationObserverRegistration* registration = 0;
     WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration> >& registry = ensureRareData().ensureMutationObserverData().registry;
-    for (size_t i = 0; i < registry.size(); ++i) {
+    for (std::size_t i = 0; i < registry.size(); ++i) {
         if (&registry[i]->observer() == &observer) {
             registration = registry[i].get();
             registration->resetObservation(options, attributeFilter);
         }
     }
 
     if (!registration) {
         registry.append(MutationObserverRegistration::create(observer, this, options, attributeFilter));
         registration = registry.last().get();
     }
 
     document().addMutationObserverTypes(registration->mutationTypes());
 }
 
 void Node::unregisterMutationObserver(MutationObserverRegistration* registration)
 {
     WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration> >* registry = mutationObserverRegistry();
     ASSERT(registry);
     if (!registry)
         return;
 
-    size_t index = registry->find(registration);
+    std::size_t index = registry->find(registration);
     ASSERT(index != kNotFound);
     if (index == kNotFound)
         return;
 
     // Deleting the registration may cause this node to be derefed, so we must make sure the Vector operation completes
     // before that, in case |this| is destroyed (see MutationObserverRegistration::m_registrationNodeKeepAlive).
     // FIXME: Simplify the registration/transient registration logic to make this understandable by humans.
     RefPtrWillBeRawPtr<Node> protect(this);
 #if ENABLE(OILPAN)
     // The explicit dispose() is needed to have the registration
@@ skipping 19 matching lines @@
     transientRegistry->remove(registration);
 }
 
 void Node::notifyMutationObserversNodeWillDetach()
 {
     if (!document().hasMutationObservers())
         return;
 
     for (Node* node = parentNode(); node; node = node->parentNode()) {
         if (WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration> >* registry = node->mutationObserverRegistry()) {
-            const size_t size = registry->size();
-            for (size_t i = 0; i < size; ++i)
+            const std::size_t size = registry->size();
+            for (std::size_t i = 0; i < size; ++i)
                 registry->at(i)->observedSubtreeNodeWillDetach(*this);
         }
 
         if (WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration> >* transientRegistry = node->transientMutationObserverRegistry()) {
             for (WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration> >::iterator iter = transientRegistry->begin(); iter != transientRegistry->end(); ++iter)
                 (*iter)->observedSubtreeNodeWillDetach(*this);
         }
     }
 }
 
@@ skipping 254 matching lines @@
     for (Node* node = parentOrShadowHostNode(); node; node = node->parentOrShadowHostNode())
         node->incrementConnectedSubframeCount(count);
 }
 
 PassRefPtrWillBeRawPtr<NodeList> Node::getDestinationInsertionPoints()
 {
     document().updateDistributionForNodeIfNeeded(this);
     WillBeHeapVector<RawPtrWillBeMember<InsertionPoint>, 8> insertionPoints;
     collectDestinationInsertionPoints(*this, insertionPoints);
     WillBeHeapVector<RefPtrWillBeMember<Node> > filteredInsertionPoints;
-    for (size_t i = 0; i < insertionPoints.size(); ++i) {
+    for (std::size_t i = 0; i < insertionPoints.size(); ++i) {
         InsertionPoint* insertionPoint = insertionPoints[i];
         ASSERT(insertionPoint->containingShadowRoot());
         if (insertionPoint->containingShadowRoot()->type() != ShadowRoot::UserAgentShadowRoot)
             filteredInsertionPoints.append(insertionPoint);
     }
     return StaticNodeList::adopt(filteredInsertionPoints);
 }
 
 void Node::registerScopedHTMLStyleChild()
 {
     setHasScopedHTMLStyleChild(true);
 }
 
 void Node::unregisterScopedHTMLStyleChild()
 {
     ASSERT(hasScopedHTMLStyleChild());
     setHasScopedHTMLStyleChild(numberOfScopedHTMLStyleChildren());
 }
 
-size_t Node::numberOfScopedHTMLStyleChildren() const
+std::size_t Node::numberOfScopedHTMLStyleChildren() const
 {
-    size_t count = 0;
+    std::size_t count = 0;
     for (HTMLStyleElement* style = Traversal<HTMLStyleElement>::firstChild(*this); style; style = Traversal<HTMLStyleElement>::nextSibling(*style)) {
         if (style->isRegisteredAsScoped())
             ++count;
     }
 
     return count;
 }
 
 void Node::setFocus(bool flag)
 {
@@ skipping 109 matching lines @@
         node->showTreeForThis();
 }
 
 void showNodePath(const WebCore::Node* node)
 {
     if (node)
         node->showNodePathForThis();
 }
 
 #endif