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

Source/core/editing/CompositeEditCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 51 matching lines @@
 #include "core/editing/htmlediting.h"
 #include "core/editing/markup.h"
 #include "core/events/ScopedEventQueue.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLElement.h"
 #include "core/rendering/InlineTextBox.h"
 #include "core/rendering/RenderBlock.h"
 #include "core/rendering/RenderListItem.h"
 #include "core/rendering/RenderText.h"
 
-using namespace std;
-
 namespace WebCore {
 
 using namespace HTMLNames;
 
 PassRefPtrWillBeRawPtr<EditCommandComposition> EditCommandComposition::create(Document* document,
     const VisibleSelection& startingSelection, const VisibleSelection& endingSelection, EditAction editAction)
 {
     return adoptRefWillBeNoop(new EditCommandComposition(document, startingSelection, endingSelection, editAction));
 }
 
@@ skipping 18 matching lines @@
     ASSERT(m_document);
     RefPtr<LocalFrame> frame = m_document->frame();
     ASSERT(frame);
 
     // Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.
     // Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one
     // if one is necessary (like for the creation of VisiblePositions).
     m_document->updateLayoutIgnorePendingStylesheets();
 
     {
-        size_t size = m_commands.size();
-        for (size_t i = size; i; --i)
+        std::size_t size = m_commands.size();
+        for (std::size_t i = size; i; --i)
             m_commands[i - 1]->doUnapply();
     }
 
     frame->editor().unappliedEditing(this);
 }
 
 void EditCommandComposition::reapply()
 {
     ASSERT(m_document);
     RefPtr<LocalFrame> frame = m_document->frame();
     ASSERT(frame);
 
     // Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.
     // Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one
     // if one is necessary (like for the creation of VisiblePositions).
     m_document->updateLayoutIgnorePendingStylesheets();
 
     {
-        size_t size = m_commands.size();
-        for (size_t i = 0; i != size; ++i)
+        std::size_t size = m_commands.size();
+        for (std::size_t i = 0; i != size; ++i)
             m_commands[i]->doReapply();
     }
 
     frame->editor().reappliedEditing(this);
 }
 
 void EditCommandComposition::append(SimpleEditCommand* command)
 {
     m_commands.append(command);
 }
@@ skipping 217 matching lines @@
     applyCommandToComposite(AppendNodeCommand::create(parent, node));
 }
 
 void CompositeEditCommand::removeChildrenInRange(PassRefPtrWillBeRawPtr<Node> node, unsigned from, unsigned to)
 {
     WillBeHeapVector<RefPtrWillBeMember<Node> > children;
     Node* child = node->traverseToChildAt(from);
     for (unsigned i = from; child && i < to; i++, child = child->nextSibling())
         children.append(child);
 
-    size_t size = children.size();
-    for (size_t i = 0; i < size; ++i)
+    std::size_t size = children.size();
+    for (std::size_t i = 0; i < size; ++i)
         removeNode(children[i].release());
 }
 
 void CompositeEditCommand::removeNode(PassRefPtrWillBeRawPtr<Node> node, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
 {
     if (!node || !node->nonShadowBoundaryParentNode())
         return;
     applyCommandToComposite(RemoveNodeCommand::create(node, shouldAssumeContentIsAlwaysEditable));
 }
 
@@ skipping 111 matching lines @@
         return Position();
 
     RefPtrWillBeRawPtr<Text> textNode = start.containerText();
     replaceTextInNode(textNode, start.offsetInContainerNode(), end.offsetInContainerNode() - start.offsetInContainerNode(), text);
 
     return Position(textNode.release(), start.offsetInContainerNode() + text.length());
 }
 
 static void copyMarkers(const WillBeHeapVector<DocumentMarker*>& markerPointers, Vector<DocumentMarker>& markers)
 {
-    size_t arraySize = markerPointers.size();
+    std::size_t arraySize = markerPointers.size();
     markers.reserveCapacity(arraySize);
-    for (size_t i = 0; i < arraySize; ++i)
+    for (std::size_t i = 0; i < arraySize; ++i)
         markers.append(*markerPointers[i]);
 }
 
 void CompositeEditCommand::replaceTextInNodePreservingMarkers(PassRefPtrWillBeRawPtr<Text> prpNode, unsigned offset, unsigned count, const String& replacementText)
 {
     RefPtrWillBeRawPtr<Text> node(prpNode);
     DocumentMarkerController& markerController = document().markers();
     Vector<DocumentMarker> markers;
     copyMarkers(markerController.markersInRange(Range::create(document(), node.get(), offset, node.get(), offset + count).get(), DocumentMarker::AllMarkers()), markers);
     replaceTextInNode(node, offset, count, replacementText);
     RefPtrWillBeRawPtr<Range> newRange = Range::create(document(), node.get(), offset, node.get(), offset + replacementText.length());
-    for (size_t i = 0; i < markers.size(); ++i)
+    for (std::size_t i = 0; i < markers.size(); ++i)
         markerController.addMarker(newRange.get(), markers[i].type(), markers[i].description());
 }
 
 Position CompositeEditCommand::positionOutsideTabSpan(const Position& pos)
 {
     if (!isTabSpanTextNode(pos.anchorNode()))
         return pos;
 
     switch (pos.anchorType()) {
     case Position::PositionIsBeforeChildren:
@@ skipping 189 matching lines @@
     if (!textNode || start >= end)
         return;
 
     document().updateLayout();
 
     RenderText* textRenderer = toRenderText(textNode->renderer());
     if (!textRenderer)
         return;
 
     Vector<InlineTextBox*> sortedTextBoxes;
-    size_t sortedTextBoxesPosition = 0;
+    std::size_t sortedTextBoxesPosition = 0;
 
     for (InlineTextBox* textBox = textRenderer->firstTextBox(); textBox; textBox = textBox->nextTextBox())
         sortedTextBoxes.append(textBox);
 
     // If there is mixed directionality text, the boxes can be out of order,
     // (like Arabic with embedded LTR), so sort them first.
     if (textRenderer->containsReversedText())
         std::sort(sortedTextBoxes.begin(), sortedTextBoxes.end(), InlineTextBox::compareByStart);
     InlineTextBox* box = sortedTextBoxes.isEmpty() ? 0 : sortedTextBoxes[sortedTextBoxesPosition];
 
@@ skipping 16 matching lines @@
     while (prevBox || box) {
         unsigned gapStart = prevBox ? prevBox->start() + prevBox->len() : 0;
         if (end < gapStart)
             // No more chance for any intersections
             break;
 
         unsigned gapEnd = box ? box->start() : length;
         bool indicesIntersect = start <= gapEnd && end >= gapStart;
         int gapLen = gapEnd - gapStart;
         if (indicesIntersect && gapLen > 0) {
-            gapStart = max(gapStart, start);
+            gapStart = std::max(gapStart, start);
             if (str.isNull())
                 str = textNode->data().substring(start, end - start);
             // remove text in the gap
             str.remove(gapStart - start - removed, gapLen);
             removed += gapLen;
         }
 
         prevBox = box;
         if (box) {
             if (++sortedTextBoxesPosition < sortedTextBoxes.size())
@@ skipping 26 matching lines @@
         return;
 
     WillBeHeapVector<RefPtrWillBeMember<Text> > nodes;
     for (Node* node = start.deprecatedNode(); node; node = NodeTraversal::next(*node)) {
         if (node->isTextNode())
             nodes.append(toText(node));
         if (node == end.deprecatedNode())
             break;
     }
 
-    for (size_t i = 0; i < nodes.size(); ++i) {
+    for (std::size_t i = 0; i < nodes.size(); ++i) {
         Text* textNode = nodes[i].get();
         int startOffset = textNode == start.deprecatedNode() ? start.deprecatedEditingOffset() : 0;
         int endOffset = textNode == end.deprecatedNode() ? end.deprecatedEditingOffset() : static_cast<int>(textNode->length());
         deleteInsignificantText(textNode, startOffset, endOffset);
     }
 }
 
 void CompositeEditCommand::deleteInsignificantTextDownstream(const Position& pos)
 {
     Position end = VisiblePosition(pos, VP_DEFAULT_AFFINITY).next().deepEquivalent().downstream();
@@ skipping 176 matching lines @@
 
     if (start.anchorNode() != outerNode && lastNode->isElementNode() && start.anchorNode()->isDescendantOf(outerNode.get())) {
         WillBeHeapVector<RefPtrWillBeMember<Node> > ancestors;
 
         // Insert each node from innerNode to outerNode (excluded) in a list.
         for (Node* n = start.deprecatedNode(); n && n != outerNode; n = n->parentNode())
             ancestors.append(n);
 
         // Clone every node between start.deprecatedNode() and outerBlock.
 
-        for (size_t i = ancestors.size(); i != 0; --i) {
+        for (std::size_t i = ancestors.size(); i != 0; --i) {
             Node* item = ancestors[i - 1].get();
             RefPtrWillBeRawPtr<Node> child = item->cloneNode(isRenderedTableElement(item));
             appendNode(child, toElement(lastNode));
             lastNode = child.release();
         }
     }
 
     // Scripts specified in javascript protocol may remove |outerNode|
     // during insertion, e.g. <iframe src="javascript:...">
     if (!outerNode->inDocument())
@@ skipping 477 matching lines @@
 }
 
 void CompositeEditCommand::trace(Visitor* visitor)
 {
     visitor->trace(m_commands);
     visitor->trace(m_composition);
     EditCommand::trace(visitor);
 }
 
 } // namespace WebCore