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

Source/core/editing/TextIterator.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2005 Alexey Proskuryakov.
  *
  * 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
@@ skipping 37 matching lines @@
 #include "platform/text/TextBoundaries.h"
 #include "platform/text/TextBreakIteratorInternalICU.h"
 #include "platform/text/UnicodeUtilities.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/unicode/CharacterNames.h"
 #include <unicode/usearch.h>
 #include <unicode/utf16.h>
 
 using namespace WTF::Unicode;
-using namespace std;
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 // Buffer that knows how to compare with a search target.
 // Keeps enough of the previous text to be able to search in the future, but no more.
 // Non-breaking spaces are always equal to normal spaces.
 // Case folding is also done if the CaseInsensitive option is specified.
 // Matches are further filtered if the AtWordStarts option is specified, although some
 // matches inside a word are permitted if TreatMedialCapitalAsWordStart is specified as well.
 class SearchBuffer {
     WTF_MAKE_NONCOPYABLE(SearchBuffer);
 public:
     SearchBuffer(const String& target, FindOptions);
     ~SearchBuffer();
 
     // Returns number of characters appended; guaranteed to be in the range [1, length].
     template<typename CharType>
-    void append(const CharType*, size_t length);
-    size_t numberOfCharactersJustAppended() const { return m_numberOfCharactersJustAppended; }
+    void append(const CharType*, std::size_t length);
+    std::size_t numberOfCharactersJustAppended() const { return m_numberOfCharactersJustAppended; }
 
     bool needsMoreContext() const;
-    void prependContext(const UChar*, size_t length);
+    void prependContext(const UChar*, std::size_t length);
     void reachedBreak();
 
     // Result is the size in characters of what was found.
     // And <startOffset> is the number of characters back to the start of what was found.
-    size_t search(size_t& startOffset);
+    std::size_t search(std::size_t& startOffset);
     bool atBreak() const;
 
 private:
-    bool isBadMatch(const UChar*, size_t length) const;
-    bool isWordStartMatch(size_t start, size_t length) const;
+    bool isBadMatch(const UChar*, std::size_t length) const;
+    bool isWordStartMatch(std::size_t start, std::size_t length) const;
 
     Vector<UChar> m_target;
     FindOptions m_options;
 
     Vector<UChar> m_buffer;
-    size_t m_overlap;
-    size_t m_prefixLength;
-    size_t m_numberOfCharactersJustAppended;
+    std::size_t m_overlap;
+    std::size_t m_prefixLength;
+    std::size_t m_numberOfCharactersJustAppended;
     bool m_atBreak;
     bool m_needsMoreContext;
 
     bool m_targetRequiresKanaWorkaround;
     Vector<UChar> m_normalizedTarget;
     mutable Vector<UChar> m_normalizedMatch;
 };
 
 // --------
 
@@ skipping 112 matching lines @@
 }
 
 static void setUpFullyClippedStack(BitStack& stack, Node* node)
 {
     // Put the nodes in a vector so we can iterate in reverse order.
     Vector<Node*, 100> ancestry;
     for (Node* parent = node->parentOrShadowHostNode(); parent; parent = parent->parentOrShadowHostNode())
         ancestry.append(parent);
 
     // Call pushFullyClippedState on each node starting with the earliest ancestor.
-    size_t size = ancestry.size();
-    for (size_t i = 0; i < size; ++i)
+    std::size_t size = ancestry.size();
+    for (std::size_t i = 0; i < size; ++i)
         pushFullyClippedState(stack, ancestry[size - i - 1]);
     pushFullyClippedState(stack, node);
 
     ASSERT(stack.size() == 1 + depthCrossingShadowBoundaries(node));
 }
 
 // --------
 
 TextIterator::TextIterator(const Range* range, TextIteratorBehaviorFlags behavior)
     : m_startContainer(nullptr)
@@ skipping 366 matching lines @@
                 emitText(m_node, m_firstLetterText, m_offset, m_offset + firstLetter.length());
                 m_firstLetterText = 0;
                 m_textBox = 0;
                 return false;
             }
         }
         if (renderer->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility)
             return false;
         int strLength = str.length();
         int end = (m_node == m_endContainer) ? m_endOffset : INT_MAX;
-        int runEnd = min(strLength, end);
+        int runEnd = std::min(strLength, end);
 
         if (runStart >= runEnd)
             return true;
 
         emitText(m_node, runStart, runEnd);
         return true;
     }
 
     if (renderer->firstTextBox())
         m_textBox = renderer->firstTextBox();
@@ skipping 32 matching lines @@
     RenderText* renderer = m_firstLetterText ? m_firstLetterText : toRenderText(m_node->renderer());
     if (renderer->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility) {
         m_textBox = 0;
         return;
     }
     String str = renderer->text();
     unsigned start = m_offset;
     unsigned end = (m_node == m_endContainer) ? static_cast<unsigned>(m_endOffset) : INT_MAX;
     while (m_textBox) {
         unsigned textBoxStart = m_textBox->start();
-        unsigned runStart = max(textBoxStart, start);
+        unsigned runStart = std::max(textBoxStart, start);
 
         // Check for collapsed space at the start of this run.
         InlineTextBox* firstTextBox = renderer->containsReversedText() ? (m_sortedTextBoxes.isEmpty() ? 0 : m_sortedTextBoxes[0]) : renderer->firstTextBox();
         bool needSpace = m_lastTextNodeEndedWithCollapsedSpace
             || (m_textBox == firstTextBox && textBoxStart == runStart && runStart > 0);
         if (needSpace && !renderer->style()->isCollapsibleWhiteSpace(m_lastCharacter) && m_lastCharacter) {
             if (m_lastTextNode == m_node && runStart > 0 && str[runStart - 1] == ' ') {
                 unsigned spaceRunStart = runStart - 1;
                 while (spaceRunStart > 0 && str[spaceRunStart - 1] == ' ')
                     --spaceRunStart;
                 emitText(m_node, renderer, spaceRunStart, spaceRunStart + 1);
             } else {
                 emitCharacter(' ', m_node, 0, runStart, runStart);
             }
             return;
         }
         unsigned textBoxEnd = textBoxStart + m_textBox->len();
-        unsigned runEnd = min(textBoxEnd, end);
+        unsigned runEnd = std::min(textBoxEnd, end);
 
         // Determine what the next text box will be, but don't advance yet
         InlineTextBox* nextTextBox = 0;
         if (renderer->containsReversedText()) {
             if (m_sortedTextBoxesPosition + 1 < m_sortedTextBoxes.size())
                 nextTextBox = m_sortedTextBoxes[m_sortedTextBoxesPosition + 1];
         } else {
             nextTextBox = m_textBox->nextTextBox();
         }
         ASSERT(!nextTextBox || nextTextBox->renderer() == renderer);
 
         if (runStart < runEnd) {
             // Handle either a single newline character (which becomes a space),
             // or a run of characters that does not include a newline.
             // This effectively translates newlines to spaces without copying the text.
             if (str[runStart] == '\n') {
                 emitCharacter(' ', m_node, 0, runStart, runStart + 1);
                 m_offset = runStart + 1;
             } else {
-                size_t subrunEnd = str.find('\n', runStart);
+                std::size_t subrunEnd = str.find('\n', runStart);
                 if (subrunEnd == kNotFound || subrunEnd > runEnd)
                     subrunEnd = runEnd;
 
                 m_offset = subrunEnd;
                 emitText(m_node, renderer, runStart, subrunEnd);
             }
 
             // If we are doing a subrun that doesn't go to the end of the text box,
             // come back again to finish handling this text box; don't advance to the next one.
             if (static_cast<unsigned>(m_positionEndOffset) < textBoxEnd)
@@ skipping 1005 matching lines @@
 
 UChar WordAwareIterator::characterAt(unsigned index) const
 {
     if (!m_buffer.isEmpty())
         return m_buffer[index];
     return m_textIterator.characterAt(index);
 }
 
 // --------
 
-static const size_t minimumSearchBufferSize = 8192;
+static const std::size_t minimumSearchBufferSize = 8192;
 
 #ifndef NDEBUG
 static bool searcherInUse;
 #endif
 
 static UStringSearch* createSearcher()
 {
     // Provide a non-empty pattern and non-empty text so usearch_open will not fail,
     // but it doesn't matter exactly what it is, since we don't perform any searches
     // without setting both the pattern and the text.
@@ skipping 35 matching lines @@
     , m_targetRequiresKanaWorkaround(containsKanaLetters(target))
 {
     ASSERT(!target.isEmpty());
     target.appendTo(m_target);
 
     // FIXME: We'd like to tailor the searcher to fold quote marks for us instead
     // of doing it in a separate replacement pass here, but ICU doesn't offer a way
     // to add tailoring on top of the locale-specific tailoring as of this writing.
     foldQuoteMarksAndSoftHyphens(m_target.data(), m_target.size());
 
-    size_t targetLength = m_target.size();
-    m_buffer.reserveInitialCapacity(max(targetLength * 8, minimumSearchBufferSize));
+    std::size_t targetLength = m_target.size();
+    m_buffer.reserveInitialCapacity(std::max(targetLength * 8, minimumSearchBufferSize));
     m_overlap = m_buffer.capacity() / 4;
 
     if ((m_options & AtWordStarts) && targetLength) {
         UChar32 targetFirstCharacter;
         U16_GET(m_target.data(), 0, 0, targetLength, targetFirstCharacter);
         // Characters in the separator category never really occur at the beginning of a word,
         // so if the target begins with such a character, we just ignore the AtWordStart option.
         if (isSeparator(targetFirstCharacter)) {
             m_options &= ~AtWordStarts;
             m_needsMoreContext = false;
@@ skipping 27 matching lines @@
 {
     // Leave the static object pointing to a valid string.
     UErrorCode status = U_ZERO_ERROR;
     usearch_setPattern(WebCore::searcher(), &newlineCharacter, 1, &status);
     ASSERT(status == U_ZERO_ERROR);
 
     unlockSearcher();
 }
 
 template<typename CharType>
-inline void SearchBuffer::append(const CharType* characters, size_t length)
+inline void SearchBuffer::append(const CharType* characters, std::size_t length)
 {
     ASSERT(length);
 
     if (m_atBreak) {
         m_buffer.shrink(0);
         m_prefixLength = 0;
         m_atBreak = false;
     } else if (m_buffer.size() == m_buffer.capacity()) {
         memcpy(m_buffer.data(), m_buffer.data() + m_buffer.size() - m_overlap, m_overlap * sizeof(UChar));
-        m_prefixLength -= min(m_prefixLength, m_buffer.size() - m_overlap);
+        m_prefixLength -= std::min(m_prefixLength, m_buffer.size() - m_overlap);
         m_buffer.shrink(m_overlap);
     }
 
-    size_t oldLength = m_buffer.size();
-    size_t usableLength = min(m_buffer.capacity() - oldLength, length);
+    std::size_t oldLength = m_buffer.size();
+    std::size_t usableLength = std::min(m_buffer.capacity() - oldLength, length);
     ASSERT(usableLength);
     m_buffer.resize(oldLength + usableLength);
     UChar* destination = m_buffer.data() + oldLength;
     StringImpl::copyChars(destination, characters, usableLength);
     foldQuoteMarksAndSoftHyphens(destination, usableLength);
     m_numberOfCharactersJustAppended = usableLength;
 }
 
 inline bool SearchBuffer::needsMoreContext() const
 {
     return m_needsMoreContext;
 }
 
-inline void SearchBuffer::prependContext(const UChar* characters, size_t length)
+inline void SearchBuffer::prependContext(const UChar* characters, std::size_t length)
 {
     ASSERT(m_needsMoreContext);
     ASSERT(m_prefixLength == m_buffer.size());
 
     if (!length)
         return;
 
     m_atBreak = false;
 
-    size_t wordBoundaryContextStart = length;
+    std::size_t wordBoundaryContextStart = length;
     if (wordBoundaryContextStart) {
         U16_BACK_1(characters, 0, wordBoundaryContextStart);
         wordBoundaryContextStart = startOfLastWordBoundaryContext(characters, wordBoundaryContextStart);
     }
 
-    size_t usableLength = min(m_buffer.capacity() - m_prefixLength, length - wordBoundaryContextStart);
+    std::size_t usableLength = std::min(m_buffer.capacity() - m_prefixLength, length - wordBoundaryContextStart);
     m_buffer.prepend(characters + length - usableLength, usableLength);
     m_prefixLength += usableLength;
 
     if (wordBoundaryContextStart || m_prefixLength == m_buffer.capacity())
         m_needsMoreContext = false;
 }
 
 inline bool SearchBuffer::atBreak() const
 {
     return m_atBreak;
 }
 
 inline void SearchBuffer::reachedBreak()
 {
     m_atBreak = true;
 }
 
-inline bool SearchBuffer::isBadMatch(const UChar* match, size_t matchLength) const
+inline bool SearchBuffer::isBadMatch(const UChar* match, std::size_t matchLength) const
 {
     // This function implements the kana workaround. If usearch treats
     // it as a match, but we do not want to, then it's a "bad match".
     if (!m_targetRequiresKanaWorkaround)
         return false;
 
     // Normalize into a match buffer. We reuse a single buffer rather than
     // creating a new one each time.
     normalizeCharactersIntoNFCForm(match, matchLength, m_normalizedMatch);
 
     return !checkOnlyKanaLettersInStrings(m_normalizedTarget.begin(), m_normalizedTarget.size(), m_normalizedMatch.begin(), m_normalizedMatch.size());
 }
 
-inline bool SearchBuffer::isWordStartMatch(size_t start, size_t length) const
+inline bool SearchBuffer::isWordStartMatch(std::size_t start, std::size_t length) const
 {
     ASSERT(m_options & AtWordStarts);
 
     if (!start)
         return true;
 
     int size = m_buffer.size();
     int offset = start;
     UChar32 firstCharacter;
     U16_GET(m_buffer.data(), 0, offset, size, firstCharacter);
@@ skipping 28 matching lines @@
             // except after an uppercase. ("org" in "webkit.org", but not "ore" in "WebCore").
             return true;
         }
     }
 
     // Chinese and Japanese lack word boundary marks, and there is no clear agreement on what constitutes
     // a word, so treat the position before any CJK character as a word start.
     if (Character::isCJKIdeographOrSymbol(firstCharacter))
         return true;
 
-    size_t wordBreakSearchStart = start + length;
+    std::size_t wordBreakSearchStart = start + length;
     while (wordBreakSearchStart > start)
         wordBreakSearchStart = findNextWordFromIndex(m_buffer.data(), m_buffer.size(), wordBreakSearchStart, false /* backwards */);
     return wordBreakSearchStart == start;
 }
 
-inline size_t SearchBuffer::search(size_t& start)
+inline std::size_t SearchBuffer::search(std::size_t& start)
 {
-    size_t size = m_buffer.size();
+    std::size_t size = m_buffer.size();
     if (m_atBreak) {
         if (!size)
             return 0;
     } else {
         if (size != m_buffer.capacity())
             return 0;
     }
 
     UStringSearch* searcher = WebCore::searcher();
 
     UErrorCode status = U_ZERO_ERROR;
     usearch_setText(searcher, m_buffer.data(), size, &status);
     ASSERT(status == U_ZERO_ERROR);
 
     usearch_setOffset(searcher, m_prefixLength, &status);
     ASSERT(status == U_ZERO_ERROR);
 
     int matchStart = usearch_next(searcher, &status);
     ASSERT(status == U_ZERO_ERROR);
 
 nextMatch:
-    if (!(matchStart >= 0 && static_cast<size_t>(matchStart) < size)) {
+    if (!(matchStart >= 0 && static_cast<std::size_t>(matchStart) < size)) {
         ASSERT(matchStart == USEARCH_DONE);
         return 0;
     }
 
     // Matches that start in the overlap area are only tentative.
     // The same match may appear later, matching more characters,
     // possibly including a combining character that's not yet in the buffer.
-    if (!m_atBreak && static_cast<size_t>(matchStart) >= size - m_overlap) {
-        size_t overlap = m_overlap;
+    if (!m_atBreak && static_cast<std::size_t>(matchStart) >= size - m_overlap) {
+        std::size_t overlap = m_overlap;
         if (m_options & AtWordStarts) {
             // Ensure that there is sufficient context before matchStart the next time around for
             // determining if it is at a word boundary.
             int wordBoundaryContextStart = matchStart;
             U16_BACK_1(m_buffer.data(), 0, wordBoundaryContextStart);
             wordBoundaryContextStart = startOfLastWordBoundaryContext(m_buffer.data(), wordBoundaryContextStart);
-            overlap = min(size - 1, max(overlap, size - wordBoundaryContextStart));
+            overlap = std::min(size - 1, std::max(overlap, size - wordBoundaryContextStart));
         }
         memcpy(m_buffer.data(), m_buffer.data() + size - overlap, overlap * sizeof(UChar));
-        m_prefixLength -= min(m_prefixLength, size - overlap);
+        m_prefixLength -= std::min(m_prefixLength, size - overlap);
         m_buffer.shrink(overlap);
         return 0;
     }
 
-    size_t matchedLength = usearch_getMatchedLength(searcher);
+    std::size_t matchedLength = usearch_getMatchedLength(searcher);
     ASSERT_WITH_SECURITY_IMPLICATION(matchStart + matchedLength <= size);
 
     // If this match is "bad", move on to the next match.
     if (isBadMatch(m_buffer.data() + matchStart, matchedLength) || ((m_options & AtWordStarts) && !isWordStartMatch(matchStart, matchedLength))) {
         matchStart = usearch_next(searcher, &status);
         ASSERT(status == U_ZERO_ERROR);
         goto nextMatch;
     }
 
-    size_t newSize = size - (matchStart + 1);
+    std::size_t newSize = size - (matchStart + 1);
     memmove(m_buffer.data(), m_buffer.data() + matchStart + 1, newSize * sizeof(UChar));
-    m_prefixLength -= min<size_t>(m_prefixLength, matchStart + 1);
+    m_prefixLength -= std::min<std::size_t>(m_prefixLength, matchStart + 1);
     m_buffer.shrink(newSize);
 
     start = size - matchStart;
     return matchedLength;
 }
 
 // --------
 
 int TextIterator::rangeLength(const Range* r, bool forSelectionPreservation)
 {
@@ skipping 42 matching lines @@
     return result.release();
 }
 
 // Check if there's any unpaird surrogate code point.
 // Non-character code points are not checked.
 static bool isValidUTF16(const String& s)
 {
     if (s.is8Bit())
         return true;
     const UChar* ustr = s.characters16();
-    size_t length = s.length();
-    size_t position = 0;
+    std::size_t length = s.length();
+    std::size_t position = 0;
     while (position < length) {
         UChar32 character;
         U16_NEXT(ustr, position, length, character);
         if (U_IS_SURROGATE(character))
             return false;
     }
     return true;
 }
 
-static size_t findPlainTextInternal(CharacterIterator& it, const String& target, FindOptions options, size_t& matchStart)
+static std::size_t findPlainTextInternal(CharacterIterator& it, const String& target, FindOptions options, std::size_t& matchStart)
 {
     matchStart = 0;
-    size_t matchLength = 0;
+    std::size_t matchLength = 0;
 
     if (!isValidUTF16(target))
         return 0;
 
     SearchBuffer buffer(target, options);
 
     if (buffer.needsMoreContext()) {
         RefPtrWillBeRawPtr<Range> startRange = it.range();
         RefPtrWillBeRawPtr<Range> beforeStartRange = startRange->ownerDocument().createRange();
         beforeStartRange->setEnd(startRange->startContainer(), startRange->startOffset(), IGNORE_EXCEPTION);
         for (SimplifiedBackwardsTextIterator backwardsIterator(beforeStartRange.get()); !backwardsIterator.atEnd(); backwardsIterator.advance()) {
             Vector<UChar, 1024> characters;
             backwardsIterator.prependTextTo(characters);
             buffer.prependContext(characters.data(), characters.size());
             if (!buffer.needsMoreContext())
                 break;
         }
     }
 
     while (!it.atEnd()) {
         it.appendTextTo(buffer);
         it.advance(buffer.numberOfCharactersJustAppended());
 tryAgain:
-        size_t matchStartOffset;
-        if (size_t newMatchLength = buffer.search(matchStartOffset)) {
+        std::size_t matchStartOffset;
+        if (std::size_t newMatchLength = buffer.search(matchStartOffset)) {
             // Note that we found a match, and where we found it.
-            size_t lastCharacterInBufferOffset = it.characterOffset();
+            std::size_t lastCharacterInBufferOffset = it.characterOffset();
             ASSERT(lastCharacterInBufferOffset >= matchStartOffset);
             matchStart = lastCharacterInBufferOffset - matchStartOffset;
             matchLength = newMatchLength;
             // If searching forward, stop on the first match.
             // If searching backward, don't stop, so we end up with the last match.
             if (!(options & Backwards))
                 break;
             goto tryAgain;
         }
         if (it.atBreak() && !buffer.atBreak()) {
             buffer.reachedBreak();
             goto tryAgain;
         }
     }
 
     return matchLength;
 }
 
 static const TextIteratorBehaviorFlags iteratorFlagsForFindPlainText = TextIteratorEntersTextControls | TextIteratorEntersAuthorShadowRoots;
 
 PassRefPtrWillBeRawPtr<Range> findPlainText(const Range* range, const String& target, FindOptions options)
 {
     // CharacterIterator requires renderers to be up-to-date
     range->ownerDocument().updateLayout();
 
     // First, find the text.
-    size_t matchStart;
-    size_t matchLength;
+    std::size_t matchStart;
+    std::size_t matchLength;
     {
         CharacterIterator findIterator(range, iteratorFlagsForFindPlainText);
         matchLength = findPlainTextInternal(findIterator, target, options, matchStart);
         if (!matchLength)
             return collapsedToBoundary(range, !(options & Backwards));
     }
 
     // Then, find the document position of the start and the end of the text.
     CharacterIterator computeRangeIterator(range, iteratorFlagsForFindPlainText);
     Position resultStart;
     Position resultEnd;
     calculateCharacterSubrange(computeRangeIterator, matchStart, matchLength, resultStart, resultEnd);
     return Range::create(range->ownerDocument(), resultStart, resultEnd);
 }
 
 void findPlainText(const Position& inputStart, const Position& inputEnd, const String& target, FindOptions options, Position& resultStart, Position& resultEnd)
 {
     resultStart.clear();
     resultEnd.clear();
     // CharacterIterator requires renderers to be up-to-date.
     if (!inputStart.inDocument())
         return;
     ASSERT(inputStart.document() == inputEnd.document());
     inputStart.document()->updateLayout();
 
     // FIXME: Reduce the code duplication with above (but how?).
-    size_t matchStart;
-    size_t matchLength;
+    std::size_t matchStart;
+    std::size_t matchLength;
     {
         CharacterIterator findIterator(inputStart, inputEnd, iteratorFlagsForFindPlainText);
         matchLength = findPlainTextInternal(findIterator, target, options, matchStart);
         if (!matchLength) {
             const Position& collapseTo = options & Backwards ? inputStart : inputEnd;
             resultStart = collapseTo;
             resultEnd = collapseTo;
             return;
         }
     }
 
     CharacterIterator computeRangeIterator(inputStart, inputEnd, iteratorFlagsForFindPlainText);
     calculateCharacterSubrange(computeRangeIterator, matchStart, matchLength, resultStart, resultEnd);
 }
 
 }