Removing "using" declarations that import names in the C++ Standard library.(Source/platform/[fonts…

Source/platform/text/TextBreakIteratorICU.cpp

 /*
  * Copyright (C) 2006 Lars Knoll <lars@trolltech.com>
  * Copyright (C) 2007, 2011, 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 17 matching lines @@
 #include "wtf/PassOwnPtr.h"
 #include "wtf/ThreadSpecific.h"
 #include "wtf/ThreadingPrimitives.h"
 #include "wtf/text/AtomicString.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/WTFString.h"
 #include <unicode/rbbi.h>
 #include <unicode/ubrk.h>
 
 using namespace WTF;
-using namespace std;
 
 namespace blink {
 
 class LineBreakIteratorPool {
     WTF_MAKE_NONCOPYABLE(LineBreakIteratorPool);
 public:
     static LineBreakIteratorPool& sharedPool()
     {
         static WTF::ThreadSpecific<LineBreakIteratorPool>* pool = new WTF::ThreadSpecific<LineBreakIteratorPool>;
         return **pool;
@@ skipping 98 matching lines @@
 {
     ASSERT_UNUSED(deep, !deep);
     if (U_FAILURE(*status))
         return 0;
     int32_t extraSize = source->extraSize;
     destination = utext_setup(destination, extraSize, status);
     if (U_FAILURE(*status))
         return destination;
     void* extraNew = destination->pExtra;
     int32_t flags = destination->flags;
-    int sizeToCopy = min(source->sizeOfStruct, destination->sizeOfStruct);
+    int sizeToCopy = std::min(source->sizeOfStruct, destination->sizeOfStruct);
     memcpy(destination, source, sizeToCopy);
     destination->pExtra = extraNew;
     destination->flags = flags;
     memcpy(destination->pExtra, source->pExtra, extraSize);
     textFixPointer(source, destination, destination->context);
     textFixPointer(source, destination, destination->p);
     textFixPointer(source, destination, destination->q);
     ASSERT(!destination->r);
     const void * chunkContents = static_cast<const void*>(destination->chunkContents);
     textFixPointer(source, destination, chunkContents);
@@ skipping 42 matching lines @@
             text->chunkNativeLimit = nativeLength;
     } else {
         ASSERT(nativeIndex > text->b && nativeIndex <= nativeLength);
         text->chunkNativeLimit = nativeIndex;
         text->chunkNativeStart = nativeIndex - text->extraSize / sizeof(UChar);
         if (text->chunkNativeStart < text->b)
             text->chunkNativeStart = text->b;
     }
     int64_t length = text->chunkNativeLimit - text->chunkNativeStart;
     // Ensure chunk length is well defined if computed length exceeds int32_t range.
-    ASSERT(length <= numeric_limits<int32_t>::max());
-    text->chunkLength = length <= numeric_limits<int32_t>::max() ? static_cast<int32_t>(length) : 0;
+    ASSERT(length <= std::numeric_limits<int32_t>::max());
+    text->chunkLength = length <= std::numeric_limits<int32_t>::max() ? static_cast<int32_t>(length) : 0;
     text->nativeIndexingLimit = text->chunkLength;
     text->chunkOffset = forward ? 0 : text->chunkLength;
     StringImpl::copyChars(const_cast<UChar*>(text->chunkContents), static_cast<const LChar*>(text->p) + (text->chunkNativeStart - text->b), static_cast<unsigned>(text->chunkLength));
 }
 
 static void textLatin1SwitchToPrimaryContext(UText* text, int64_t nativeIndex, int64_t nativeLength, UBool forward)
 {
     ASSERT(!text->chunkContents || text->chunkContents == text->q);
     text->chunkContents = static_cast<const UChar*>(text->pExtra);
     textLatin1MoveInPrimaryContext(text, nativeIndex, nativeLength, forward);
 }
 
 static void textLatin1MoveInPriorContext(UText* text, int64_t nativeIndex, int64_t nativeLength, UBool forward)
 {
     ASSERT(text->chunkContents == text->q);
     ASSERT(forward ? nativeIndex < text->b : nativeIndex <= text->b);
     ASSERT_UNUSED(nativeLength, forward ? nativeIndex < nativeLength : nativeIndex <= nativeLength);
     ASSERT_UNUSED(forward, forward ? nativeIndex < nativeLength : nativeIndex <= nativeLength);
     text->chunkNativeStart = 0;
     text->chunkNativeLimit = text->b;
     text->chunkLength = text->b;
     text->nativeIndexingLimit = text->chunkLength;
     int64_t offset = nativeIndex - text->chunkNativeStart;
     // Ensure chunk offset is well defined if computed offset exceeds int32_t range or chunk length.
-    ASSERT(offset <= numeric_limits<int32_t>::max());
-    text->chunkOffset = min(offset <= numeric_limits<int32_t>::max() ? static_cast<int32_t>(offset) : 0, text->chunkLength);
+    ASSERT(offset <= std::numeric_limits<int32_t>::max());
+    text->chunkOffset = std::min(offset <= std::numeric_limits<int32_t>::max() ? static_cast<int32_t>(offset) : 0, text->chunkLength);
 }
 
 static void textLatin1SwitchToPriorContext(UText* text, int64_t nativeIndex, int64_t nativeLength, UBool forward)
 {
     ASSERT(!text->chunkContents || text->chunkContents == text->pExtra);
     text->chunkContents = static_cast<const UChar*>(text->q);
     textLatin1MoveInPriorContext(text, nativeIndex, nativeLength, forward);
 }
 
 static inline bool textInChunkOrOutOfRange(UText* text, int64_t nativeIndex, int64_t nativeLength, UBool forward, UBool& isAccessible)
 {
     if (forward) {
         if (nativeIndex >= text->chunkNativeStart && nativeIndex < text->chunkNativeLimit) {
             int64_t offset = nativeIndex - text->chunkNativeStart;
             // Ensure chunk offset is well formed if computed offset exceeds int32_t range.
-            ASSERT(offset <= numeric_limits<int32_t>::max());
-            text->chunkOffset = offset <= numeric_limits<int32_t>::max() ? static_cast<int32_t>(offset) : 0;
+            ASSERT(offset <= std::numeric_limits<int32_t>::max());
+            text->chunkOffset = offset <= std::numeric_limits<int32_t>::max() ? static_cast<int32_t>(offset) : 0;
             isAccessible = TRUE;
             return true;
         }
         if (nativeIndex >= nativeLength && text->chunkNativeLimit == nativeLength) {
             text->chunkOffset = text->chunkLength;
             isAccessible = FALSE;
             return true;
         }
     } else {
         if (nativeIndex > text->chunkNativeStart && nativeIndex <= text->chunkNativeLimit) {
             int64_t offset = nativeIndex - text->chunkNativeStart;
             // Ensure chunk offset is well formed if computed offset exceeds int32_t range.
-            ASSERT(offset <= numeric_limits<int32_t>::max());
-            text->chunkOffset = offset <= numeric_limits<int32_t>::max() ? static_cast<int32_t>(offset) : 0;
+            ASSERT(offset <= std::numeric_limits<int32_t>::max());
+            text->chunkOffset = offset <= std::numeric_limits<int32_t>::max() ? static_cast<int32_t>(offset) : 0;
             isAccessible = TRUE;
             return true;
         }
         if (nativeIndex <= 0 && !text->chunkNativeStart) {
             text->chunkOffset = 0;
             isAccessible = FALSE;
             return true;
         }
     }
     return false;
@@ skipping 47 matching lines @@
     text->a = length;
     text->q = priorContext;
     text->b = priorContextLength;
 }
 
 static UText* textOpenLatin1(UTextWithBuffer* utWithBuffer, const LChar* string, unsigned length, const UChar* priorContext, int priorContextLength, UErrorCode* status)
 {
     if (U_FAILURE(*status))
         return 0;
 
-    if (!string || length > static_cast<unsigned>(numeric_limits<int32_t>::max())) {
+    if (!string || length > static_cast<unsigned>(std::numeric_limits<int32_t>::max())) {
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }
     UText* text = utext_setup(&utWithBuffer->text, sizeof(utWithBuffer->buffer), status);
     if (U_FAILURE(*status)) {
         ASSERT(!text);
         return 0;
     }
     textInit(text, &textLatin1Funcs, string, length, priorContext, priorContextLength);
     return text;
 }
 
 static inline TextContext textUTF16GetCurrentContext(const UText* text)
 {
     if (!text->chunkContents)
         return NoContext;
     return text->chunkContents == text->p ? PrimaryContext : PriorContext;
 }
 
 static void textUTF16MoveInPrimaryContext(UText* text, int64_t nativeIndex, int64_t nativeLength, UBool forward)
 {
     ASSERT(text->chunkContents == text->p);
     ASSERT_UNUSED(forward, forward ? nativeIndex >= text->b : nativeIndex > text->b);
     ASSERT_UNUSED(forward, forward ? nativeIndex < nativeLength : nativeIndex <= nativeLength);
     text->chunkNativeStart = text->b;
     text->chunkNativeLimit = nativeLength;
     int64_t length = text->chunkNativeLimit - text->chunkNativeStart;
     // Ensure chunk length is well defined if computed length exceeds int32_t range.
-    ASSERT(length <= numeric_limits<int32_t>::max());
-    text->chunkLength = length <= numeric_limits<int32_t>::max() ? static_cast<int32_t>(length) : 0;
+    ASSERT(length <= std::numeric_limits<int32_t>::max());
+    text->chunkLength = length <= std::numeric_limits<int32_t>::max() ? static_cast<int32_t>(length) : 0;
     text->nativeIndexingLimit = text->chunkLength;
     int64_t offset = nativeIndex - text->chunkNativeStart;
     // Ensure chunk offset is well defined if computed offset exceeds int32_t range or chunk length.
-    ASSERT(offset <= numeric_limits<int32_t>::max());
-    text->chunkOffset = min(offset <= numeric_limits<int32_t>::max() ? static_cast<int32_t>(offset) : 0, text->chunkLength);
+    ASSERT(offset <= std::numeric_limits<int32_t>::max());
+    text->chunkOffset = std::min(offset <= std::numeric_limits<int32_t>::max() ? static_cast<int32_t>(offset) : 0, text->chunkLength);
 }
 
 static void textUTF16SwitchToPrimaryContext(UText* text, int64_t nativeIndex, int64_t nativeLength, UBool forward)
 {
     ASSERT(!text->chunkContents || text->chunkContents == text->q);
     text->chunkContents = static_cast<const UChar*>(text->p);
     textUTF16MoveInPrimaryContext(text, nativeIndex, nativeLength, forward);
 }
 
 static void textUTF16MoveInPriorContext(UText* text, int64_t nativeIndex, int64_t nativeLength, UBool forward)
 {
     ASSERT(text->chunkContents == text->q);
     ASSERT(forward ? nativeIndex < text->b : nativeIndex <= text->b);
     ASSERT_UNUSED(nativeLength, forward ? nativeIndex < nativeLength : nativeIndex <= nativeLength);
     ASSERT_UNUSED(forward, forward ? nativeIndex < nativeLength : nativeIndex <= nativeLength);
     text->chunkNativeStart = 0;
     text->chunkNativeLimit = text->b;
     text->chunkLength = text->b;
     text->nativeIndexingLimit = text->chunkLength;
     int64_t offset = nativeIndex - text->chunkNativeStart;
     // Ensure chunk offset is well defined if computed offset exceeds int32_t range or chunk length.
-    ASSERT(offset <= numeric_limits<int32_t>::max());
-    text->chunkOffset = min(offset <= numeric_limits<int32_t>::max() ? static_cast<int32_t>(offset) : 0, text->chunkLength);
+    ASSERT(offset <= std::numeric_limits<int32_t>::max());
+    text->chunkOffset = std::min(offset <= std::numeric_limits<int32_t>::max() ? static_cast<int32_t>(offset) : 0, text->chunkLength);
 }
 
 static void textUTF16SwitchToPriorContext(UText* text, int64_t nativeIndex, int64_t nativeLength, UBool forward)
 {
     ASSERT(!text->chunkContents || text->chunkContents == text->p);
     text->chunkContents = static_cast<const UChar*>(text->q);
     textUTF16MoveInPriorContext(text, nativeIndex, nativeLength, forward);
 }
 
 static UBool textUTF16Access(UText* text, int64_t nativeIndex, UBool forward)
@@ skipping 33 matching lines @@
     0, 0, 0, 0,
     textClose,
     0, 0, 0,
 };
 
 static UText* textOpenUTF16(UText* text, const UChar* string, unsigned length, const UChar* priorContext, int priorContextLength, UErrorCode* status)
 {
     if (U_FAILURE(*status))
         return 0;
 
-    if (!string || length > static_cast<unsigned>(numeric_limits<int32_t>::max())) {
+    if (!string || length > static_cast<unsigned>(std::numeric_limits<int32_t>::max())) {
         *status = U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }
 
     text = utext_setup(text, 0, status);
     if (U_FAILURE(*status)) {
         ASSERT(!text);
         return 0;
     }
     textInit(text, &textUTF16Funcs, string, length, priorContext, priorContextLength);
@@ skipping 369 matching lines @@
         "$Tel1 $TelV $Tel0;"               // Telugu Virama (backward)
         "$Kan1 $KanV $Kan0;"               // Kannada Virama (backward)
         "$Mal1 $MalV $Mal0;"               // Malayalam Virama (backward)
         "!!safe_reverse;"
         "!!safe_forward;";
 
     return setUpIteratorWithRules(kRules, string, length);
 }
 
 }