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

Source/platform/fonts/Font.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2006, 2010, 2011 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.
@@ skipping 24 matching lines @@
 #include "platform/fonts/WidthIterator.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/text/TextRun.h"
 #include "wtf/MainThread.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/unicode/CharacterNames.h"
 #include "wtf/unicode/Unicode.h"
 
 using namespace WTF;
 using namespace Unicode;
-using namespace std;
 
 namespace blink {
 
 CodePath Font::s_codePath = AutoPath;
 
 // ============================================================================================
 // Font Implementation (Cross-Platform Portion)
 // ============================================================================================
 
 Font::Font()
@@ skipping 78 matching lines @@
 
     if (codePathToUse != ComplexPath)
         drawEmphasisMarksForSimpleText(context, runInfo, mark, point);
     else
         drawEmphasisMarksForComplexText(context, runInfo, mark, point);
 }
 
 static inline void updateGlyphOverflowFromBounds(const IntRectExtent& glyphBounds,
     const FontMetrics& fontMetrics, GlyphOverflow* glyphOverflow)
 {
-    glyphOverflow->top = max<int>(glyphOverflow->top,
+    glyphOverflow->top = std::max<int>(glyphOverflow->top,
         glyphBounds.top() - (glyphOverflow->computeBounds ? 0 : fontMetrics.ascent()));
-    glyphOverflow->bottom = max<int>(glyphOverflow->bottom,
+    glyphOverflow->bottom = std::max<int>(glyphOverflow->bottom,
         glyphBounds.bottom() - (glyphOverflow->computeBounds ? 0 : fontMetrics.descent()));
     glyphOverflow->left = glyphBounds.left();
     glyphOverflow->right = glyphBounds.right();
 }
 
 float Font::width(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
 {
     CodePath codePathToUse = codePath(run);
     if (codePathToUse != ComplexPath) {
         // The complex path is more restrictive about returning fallback fonts than the simple path, so we need an explicit test to make their behaviors match.
@@ skipping 206 matching lines @@
 static inline std::pair<GlyphData, GlyphPage*> glyphDataAndPageForNonCJKCharacterWithGlyphOrientation(UChar32 character, NonCJKGlyphOrientation orientation, GlyphData& data, GlyphPage* page, unsigned pageNumber)
 {
     if (orientation == NonCJKGlyphOrientationUpright || shouldIgnoreRotation(character)) {
         RefPtr<SimpleFontData> uprightFontData = data.fontData->uprightOrientationFontData();
         GlyphPageTreeNode* uprightNode = GlyphPageTreeNode::getRootChild(uprightFontData.get(), pageNumber);
         GlyphPage* uprightPage = uprightNode->page();
         if (uprightPage) {
             GlyphData uprightData = uprightPage->glyphDataForCharacter(character);
             // If the glyphs are the same, then we know we can just use the horizontal glyph rotated vertically to be upright.
             if (data.glyph == uprightData.glyph)
-                return make_pair(data, page);
+                return std::make_pair(data, page);

[jamesr, 2014/08/28 19:57:21]

given the number of make_pair calls i think adding

using std::make_pair;

to the top of this .cpp would be clearer

             // The glyphs are distinct, meaning that the font has a vertical-right glyph baked into it. We can't use that
             // glyph, so we fall back to the upright data and use the horizontal glyph.
             if (uprightData.fontData)
-                return make_pair(uprightData, uprightPage);
+                return std::make_pair(uprightData, uprightPage);
         }
     } else if (orientation == NonCJKGlyphOrientationVerticalRight) {
         RefPtr<SimpleFontData> verticalRightFontData = data.fontData->verticalRightOrientationFontData();
         GlyphPageTreeNode* verticalRightNode = GlyphPageTreeNode::getRootChild(verticalRightFontData.get(), pageNumber);
         GlyphPage* verticalRightPage = verticalRightNode->page();
         if (verticalRightPage) {
             GlyphData verticalRightData = verticalRightPage->glyphDataForCharacter(character);
             // If the glyphs are distinct, we will make the assumption that the font has a vertical-right glyph baked
             // into it.
             if (data.glyph != verticalRightData.glyph)
-                return make_pair(data, page);
+                return std::make_pair(data, page);
             // The glyphs are identical, meaning that we should just use the horizontal glyph.
             if (verticalRightData.fontData)
-                return make_pair(verticalRightData, verticalRightPage);
+                return std::make_pair(verticalRightData, verticalRightPage);
         }
     }
-    return make_pair(data, page);
+    return std::make_pair(data, page);
 }
 
 std::pair<GlyphData, GlyphPage*> Font::glyphDataAndPageForCharacter(UChar32 c, bool mirror, FontDataVariant variant) const
 {
     ASSERT(isMainThread());
 
     if (variant == AutoVariant) {
         if (m_fontDescription.variant() == FontVariantSmallCaps && !primaryFont()->isSVGFont()) {
             UChar32 upperC = toUpper(c);
             if (upperC != c) {
@@ skipping 19 matching lines @@
     }
 
     GlyphPage* page = 0;
     if (variant == NormalVariant) {
         // Fastest loop, for the common case (normal variant).
         while (true) {
             page = node->page();
             if (page) {
                 GlyphData data = page->glyphDataForCharacter(c);
                 if (data.fontData && (data.fontData->platformData().orientation() == Horizontal || data.fontData->isTextOrientationFallback()))
-                    return make_pair(data, page);
+                    return std::make_pair(data, page);
 
                 if (data.fontData) {
                     if (Character::isCJKIdeographOrSymbol(c)) {
                         if (!data.fontData->hasVerticalGlyphs()) {
                             // Use the broken ideograph font data. The broken ideograph font will use the horizontal width of glyphs
                             // to make sure you get a square (even for broken glyphs like symbols used for punctuation).
                             variant = BrokenIdeographVariant;
                             break;
                         }
                     } else {
                         return glyphDataAndPageForNonCJKCharacterWithGlyphOrientation(c, m_fontDescription.nonCJKGlyphOrientation(), data, page, pageNumber);
                     }
 
-                    return make_pair(data, page);
+                    return std::make_pair(data, page);
                 }
 
                 if (node->isSystemFallback())
                     break;
             }
 
             // Proceed with the fallback list.
             node = node->getChild(fontDataAt(node->level()), pageNumber);
             m_fontFallbackList->setPageNode(pageNumber, node);
         }
     }
     if (variant != NormalVariant) {
         while (true) {
             page = node->page();
             if (page) {
                 GlyphData data = page->glyphDataForCharacter(c);
                 if (data.fontData) {
                     // The variantFontData function should not normally return 0.
                     // But if it does, we will just render the capital letter big.
                     RefPtr<SimpleFontData> variantFontData = data.fontData->variantFontData(m_fontDescription, variant);
                     if (!variantFontData)
-                        return make_pair(data, page);
+                        return std::make_pair(data, page);
 
                     GlyphPageTreeNode* variantNode = GlyphPageTreeNode::getRootChild(variantFontData.get(), pageNumber);
                     GlyphPage* variantPage = variantNode->page();
                     if (variantPage) {
                         GlyphData data = variantPage->glyphDataForCharacter(c);
                         if (data.fontData)
-                            return make_pair(data, variantPage);
+                            return std::make_pair(data, variantPage);
                     }
 
                     // Do not attempt system fallback off the variantFontData. This is the very unlikely case that
                     // a font has the lowercase character but the small caps font does not have its uppercase version.
-                    return make_pair(variantFontData->missingGlyphData(), page);
+                    return std::make_pair(variantFontData->missingGlyphData(), page);
                 }
 
                 if (node->isSystemFallback())
                     break;
             }
 
             // Proceed with the fallback list.
             node = node->getChild(fontDataAt(node->level()), pageNumber);
             m_fontFallbackList->setPageNode(pageNumber, node);
         }
@@ skipping 19 matching lines @@
         if (variant != NormalVariant)
             characterFontData = characterFontData->variantFontData(m_fontDescription, variant);
     }
     if (characterFontData) {
         // Got the fallback glyph and font.
         GlyphPage* fallbackPage = GlyphPageTreeNode::getRootChild(characterFontData.get(), pageNumber)->page();
         GlyphData data = fallbackPage && fallbackPage->glyphForCharacter(c) ? fallbackPage->glyphDataForCharacter(c) : characterFontData->missingGlyphData();
         // Cache it so we don't have to do system fallback again next time.
         if (variant == NormalVariant) {
             page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
-            data.fontData->setMaxGlyphPageTreeLevel(max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
+            data.fontData->setMaxGlyphPageTreeLevel(std::max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
             if (!Character::isCJKIdeographOrSymbol(c) && data.fontData->platformData().orientation() != Horizontal && !data.fontData->isTextOrientationFallback())
                 return glyphDataAndPageForNonCJKCharacterWithGlyphOrientation(c, m_fontDescription.nonCJKGlyphOrientation(), data, page, pageNumber);
         }
-        return make_pair(data, page);
+        return std::make_pair(data, page);
     }
 
     // Even system fallback can fail; use the missing glyph in that case.
     // FIXME: It would be nicer to use the missing glyph from the last resort font instead.
     GlyphData data = primaryFont()->missingGlyphData();
     if (variant == NormalVariant) {
         page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
-        data.fontData->setMaxGlyphPageTreeLevel(max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
+        data.fontData->setMaxGlyphPageTreeLevel(std::max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
     }
-    return make_pair(data, page);
+    return std::make_pair(data, page);
 }
 
 bool Font::primaryFontHasGlyphForCharacter(UChar32 character) const
 {
     unsigned pageNumber = (character / GlyphPage::size);
 
     GlyphPageTreeNode* node = GlyphPageTreeNode::getRootChild(primaryFont(), pageNumber);
     GlyphPage* page = node->page();
 
     return page && page->glyphForCharacter(character);
@@ skipping 289 matching lines @@
                 if (delta <= 0)
                     break;
             }
         }
     }
 
     return offset;
 }
 
 } // namespace blink