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

Source/core/inspector/DOMPatchSupport.cpp

 /*
  * Copyright (C) 2012 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 36 matching lines @@
 #include "core/inspector/InspectorHistory.h"
 #include "core/xml/parser/XMLDocumentParser.h"
 #include "platform/Crypto.h"
 #include "public/platform/Platform.h"
 #include "wtf/Deque.h"
 #include "wtf/HashTraits.h"
 #include "wtf/RefPtr.h"
 #include "wtf/text/Base64.h"
 #include "wtf/text/CString.h"
 
-using namespace std;
-
 namespace WebCore {
 
 struct DOMPatchSupport::Digest {
     explicit Digest(Node* node) : m_node(node) { }
 
     String m_sha1;
     String m_attrsSHA1;
     Node* m_node;
     Vector<OwnPtr<Digest> > m_children;
 };
@@ skipping 143 matching lines @@
     m_unusedNodesMap.remove(newDigest->m_sha1);
     return result;
 }
 
 pair<DOMPatchSupport::ResultMap, DOMPatchSupport::ResultMap>
 DOMPatchSupport::diff(const Vector<OwnPtr<Digest> >& oldList, const Vector<OwnPtr<Digest> >& newList)
 {
     ResultMap newMap(newList.size());
     ResultMap oldMap(oldList.size());
 
-    for (size_t i = 0; i < oldMap.size(); ++i) {
+    for (std::size_t i = 0; i < oldMap.size(); ++i) {
         oldMap[i].first = 0;
         oldMap[i].second = 0;
     }
 
-    for (size_t i = 0; i < newMap.size(); ++i) {
+    for (std::size_t i = 0; i < newMap.size(); ++i) {
         newMap[i].first = 0;
         newMap[i].second = 0;
     }
 
     // Trim head and tail.
-    for (size_t i = 0; i < oldList.size() && i < newList.size() && oldList[i]->m_sha1 == newList[i]->m_sha1; ++i) {
+    for (std::size_t i = 0; i < oldList.size() && i < newList.size() && oldList[i]->m_sha1 == newList[i]->m_sha1; ++i) {
         oldMap[i].first = oldList[i].get();
         oldMap[i].second = i;
         newMap[i].first = newList[i].get();
         newMap[i].second = i;
     }
-    for (size_t i = 0; i < oldList.size() && i < newList.size() && oldList[oldList.size() - i - 1]->m_sha1 == newList[newList.size() - i - 1]->m_sha1; ++i) {
-        size_t oldIndex = oldList.size() - i - 1;
-        size_t newIndex = newList.size() - i - 1;
+    for (std::size_t i = 0; i < oldList.size() && i < newList.size() && oldList[oldList.size() - i - 1]->m_sha1 == newList[newList.size() - i - 1]->m_sha1; ++i) {
+        std::size_t oldIndex = oldList.size() - i - 1;
+        std::size_t newIndex = newList.size() - i - 1;
         oldMap[oldIndex].first = oldList[oldIndex].get();
         oldMap[oldIndex].second = newIndex;
         newMap[newIndex].first = newList[newIndex].get();
         newMap[newIndex].second = oldIndex;
     }
 
-    typedef HashMap<String, Vector<size_t> > DiffTable;
+    typedef HashMap<String, Vector<std::size_t> > DiffTable;
     DiffTable newTable;
     DiffTable oldTable;
 
-    for (size_t i = 0; i < newList.size(); ++i) {
-        newTable.add(newList[i]->m_sha1, Vector<size_t>()).storedValue->value.append(i);
+    for (std::size_t i = 0; i < newList.size(); ++i) {
+        newTable.add(newList[i]->m_sha1, Vector<std::size_t>()).storedValue->value.append(i);
     }
 
-    for (size_t i = 0; i < oldList.size(); ++i) {
-        oldTable.add(oldList[i]->m_sha1, Vector<size_t>()).storedValue->value.append(i);
+    for (std::size_t i = 0; i < oldList.size(); ++i) {
+        oldTable.add(oldList[i]->m_sha1, Vector<std::size_t>()).storedValue->value.append(i);
     }
 
     for (DiffTable::iterator newIt = newTable.begin(); newIt != newTable.end(); ++newIt) {
         if (newIt->value.size() != 1)
             continue;
 
         DiffTable::iterator oldIt = oldTable.find(newIt->key);
         if (oldIt == oldTable.end() || oldIt->value.size() != 1)
             continue;
 
-        newMap[newIt->value[0]] = make_pair(newList[newIt->value[0]].get(), oldIt->value[0]);
-        oldMap[oldIt->value[0]] = make_pair(oldList[oldIt->value[0]].get(), newIt->value[0]);
+        newMap[newIt->value[0]] = std::make_pair(newList[newIt->value[0]].get(), oldIt->value[0]);
+        oldMap[oldIt->value[0]] = std::make_pair(oldList[oldIt->value[0]].get(), newIt->value[0]);
     }
 
-    for (size_t i = 0; newList.size() > 0 && i < newList.size() - 1; ++i) {
+    for (std::size_t i = 0; newList.size() > 0 && i < newList.size() - 1; ++i) {
         if (!newMap[i].first || newMap[i + 1].first)
             continue;
 
-        size_t j = newMap[i].second + 1;
+        std::size_t j = newMap[i].second + 1;
         if (j < oldMap.size() && !oldMap[j].first && newList[i + 1]->m_sha1 == oldList[j]->m_sha1) {
-            newMap[i + 1] = make_pair(newList[i + 1].get(), j);
-            oldMap[j] = make_pair(oldList[j].get(), i + 1);
+            newMap[i + 1] = std::make_pair(newList[i + 1].get(), j);
+            oldMap[j] = std::make_pair(oldList[j].get(), i + 1);
         }
     }
 
-    for (size_t i = newList.size() - 1; newList.size() > 0 && i > 0; --i) {
+    for (std::size_t i = newList.size() - 1; newList.size() > 0 && i > 0; --i) {
         if (!newMap[i].first || newMap[i - 1].first || newMap[i].second <= 0)
             continue;
 
-        size_t j = newMap[i].second - 1;
+        std::size_t j = newMap[i].second - 1;
         if (!oldMap[j].first && newList[i - 1]->m_sha1 == oldList[j]->m_sha1) {
-            newMap[i - 1] = make_pair(newList[i - 1].get(), j);
-            oldMap[j] = make_pair(oldList[j].get(), i - 1);
+            newMap[i - 1] = std::make_pair(newList[i - 1].get(), j);
+            oldMap[j] = std::make_pair(oldList[j].get(), i - 1);
         }
     }
 
 #ifdef DEBUG_DOM_PATCH_SUPPORT
     dumpMap(oldMap, "OLD");
     dumpMap(newMap, "NEW");
 #endif
 
-    return make_pair(oldMap, newMap);
+    return std::make_pair(oldMap, newMap);
 }
 
 bool DOMPatchSupport::innerPatchChildren(ContainerNode* parentNode, const Vector<OwnPtr<Digest> >& oldList, const Vector<OwnPtr<Digest> >& newList, ExceptionState& exceptionState)
 {
     pair<ResultMap, ResultMap> resultMaps = diff(oldList, newList);
     ResultMap& oldMap = resultMaps.first;
     ResultMap& newMap = resultMaps.second;
 
     Digest* oldHead = 0;
     Digest* oldBody = 0;
 
     // 1. First strip everything except for the nodes that retain. Collect pending merges.
     HashMap<Digest*, Digest*> merges;
-    HashSet<size_t, WTF::IntHash<size_t>, WTF::UnsignedWithZeroKeyHashTraits<size_t> > usedNewOrdinals;
-    for (size_t i = 0; i < oldList.size(); ++i) {
+    HashSet<std::size_t, WTF::IntHash<std::size_t>, WTF::UnsignedWithZeroKeyHashTraits<std::size_t> > usedNewOrdinals;
+    for (std::size_t i = 0; i < oldList.size(); ++i) {
         if (oldMap[i].first) {
             if (usedNewOrdinals.add(oldMap[i].second).isNewEntry)
                 continue;
             oldMap[i].first = 0;
             oldMap[i].second = 0;
         }
 
         // Always match <head> and <body> tags with each other - we can't remove them from the DOM
         // upon patching.
         if (isHTMLHeadElement(*oldList[i]->m_node)) {
             oldHead = oldList[i].get();
             continue;
         }
         if (isHTMLBodyElement(*oldList[i]->m_node)) {
             oldBody = oldList[i].get();
             continue;
         }
 
         // Check if this change is between stable nodes. If it is, consider it as "modified".
         if (!m_unusedNodesMap.contains(oldList[i]->m_sha1) && (!i || oldMap[i - 1].first) && (i == oldMap.size() - 1 || oldMap[i + 1].first)) {
-            size_t anchorCandidate = i ? oldMap[i - 1].second + 1 : 0;
-            size_t anchorAfter = (i == oldMap.size() - 1) ? anchorCandidate + 1 : oldMap[i + 1].second;
+            std::size_t anchorCandidate = i ? oldMap[i - 1].second + 1 : 0;
+            std::size_t anchorAfter = (i == oldMap.size() - 1) ? anchorCandidate + 1 : oldMap[i + 1].second;
             if (anchorAfter - anchorCandidate == 1 && anchorCandidate < newList.size())
                 merges.set(newList[anchorCandidate].get(), oldList[i].get());
             else {
                 if (!removeChildAndMoveToNew(oldList[i].get(), exceptionState))
                     return false;
             }
         } else {
             if (!removeChildAndMoveToNew(oldList[i].get(), exceptionState))
                 return false;
         }
     }
 
     // Mark retained nodes as used, do not reuse node more than once.
-    HashSet<size_t, WTF::IntHash<size_t>, WTF::UnsignedWithZeroKeyHashTraits<size_t> >  usedOldOrdinals;
-    for (size_t i = 0; i < newList.size(); ++i) {
+    HashSet<std::size_t, WTF::IntHash<std::size_t>, WTF::UnsignedWithZeroKeyHashTraits<std::size_t> >  usedOldOrdinals;
+    for (std::size_t i = 0; i < newList.size(); ++i) {
         if (!newMap[i].first)
             continue;
-        size_t oldOrdinal = newMap[i].second;
+        std::size_t oldOrdinal = newMap[i].second;
         if (usedOldOrdinals.contains(oldOrdinal)) {
             // Do not map node more than once
             newMap[i].first = 0;
             newMap[i].second = 0;
             continue;
         }
         usedOldOrdinals.add(oldOrdinal);
         markNodeAsUsed(newMap[i].first);
     }
 
     // Mark <head> and <body> nodes for merge.
     if (oldHead || oldBody) {
-        for (size_t i = 0; i < newList.size(); ++i) {
+        for (std::size_t i = 0; i < newList.size(); ++i) {
             if (oldHead && isHTMLHeadElement(*newList[i]->m_node))
                 merges.set(newList[i].get(), oldHead);
             if (oldBody && isHTMLBodyElement(*newList[i]->m_node))
                 merges.set(newList[i].get(), oldBody);
         }
     }
 
     // 2. Patch nodes marked for merge.
     for (HashMap<Digest*, Digest*>::iterator it = merges.begin(); it != merges.end(); ++it) {
         if (!innerPatchNode(it->value, it->key, exceptionState))
             return false;
     }
 
     // 3. Insert missing nodes.
-    for (size_t i = 0; i < newMap.size(); ++i) {
+    for (std::size_t i = 0; i < newMap.size(); ++i) {
         if (newMap[i].first || merges.contains(newList[i].get()))
             continue;
         if (!insertBeforeAndMarkAsUsed(parentNode, newList[i].get(), parentNode->traverseToChildAt(i), exceptionState))
             return false;
     }
 
     // 4. Then put all nodes that retained into their slots (sort by new index).
-    for (size_t i = 0; i < oldMap.size(); ++i) {
+    for (std::size_t i = 0; i < oldMap.size(); ++i) {
         if (!oldMap[i].first)
             continue;
         RefPtrWillBeRawPtr<Node> node = oldMap[i].first->m_node;
         Node* anchorNode = parentNode->traverseToChildAt(oldMap[i].second);
         if (node == anchorNode)
             continue;
         if (isHTMLBodyElement(*node) || isHTMLHeadElement(*node))
             continue; // Never move head or body, move the rest of the nodes around them.
 
         if (!m_domEditor->insertBefore(parentNode, node.release(), anchorNode, exceptionState))
@@ skipping 73 matching lines @@
     if (it != m_unusedNodesMap.end()) {
         Digest* newDigest = it->value;
         Node* newNode = newDigest->m_node;
         if (!m_domEditor->replaceChild(newNode->parentNode(), oldNode, newNode, exceptionState))
             return false;
         newDigest->m_node = oldNode.get();
         markNodeAsUsed(newDigest);
         return true;
     }
 
-    for (size_t i = 0; i < oldDigest->m_children.size(); ++i) {
+    for (std::size_t i = 0; i < oldDigest->m_children.size(); ++i) {
         if (!removeChildAndMoveToNew(oldDigest->m_children[i].get(), exceptionState))
             return false;
     }
     return true;
 }
 
 void DOMPatchSupport::markNodeAsUsed(Digest* digest)
 {
     Deque<Digest*> queue;
     queue.append(digest);
     while (!queue.isEmpty()) {
         Digest* first = queue.takeFirst();
         m_unusedNodesMap.remove(first->m_sha1);
-        for (size_t i = 0; i < first->m_children.size(); ++i)
+        for (std::size_t i = 0; i < first->m_children.size(); ++i)
             queue.append(first->m_children[i].get());
     }
 }
 
 #ifdef DEBUG_DOM_PATCH_SUPPORT
 static String nodeName(Node* node)
 {
     if (node->document().isXHTMLDocument())
          return node->nodeName();
     return node->nodeName().lower();
 }
 
 void DOMPatchSupport::dumpMap(const ResultMap& map, const String& name)
 {
     fprintf(stderr, "\n\n");
-    for (size_t i = 0; i < map.size(); ++i)
+    for (std::size_t i = 0; i < map.size(); ++i)
         fprintf(stderr, "%s[%lu]: %s (%p) - [%lu]\n", name.utf8().data(), i, map[i].first ? nodeName(map[i].first->m_node).utf8().data() : "", map[i].first, map[i].second);
 }
 #endif
 
 } // namespace WebCore