blink: Rename platform/ methods to prefix with get when they collide.

third_party/WebKit/Source/core/layout/LayoutText.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 776 matching lines @@
     ASSERT(m_text);
     StringImpl& text = *m_text.impl();
     if (text[0] == spaceCharacter || (text[0] == newlineCharacter && !style()->preserveNewline()) || text[0] == tabulationCharacter) {
         const Font& font = style()->font(); // FIXME: This ignores first-line.
         if (stripFrontSpaces) {
             const UChar spaceChar = spaceCharacter;
             TextRun run = constructTextRun(font, &spaceChar, 1, styleRef(), direction);
             float spaceWidth = font.width(run);
             floatMaxWidth -= spaceWidth;
         } else {
-            floatMaxWidth += font.fontDescription().wordSpacing();
+            floatMaxWidth += font.getFontDescription().wordSpacing();
         }
     }
 
     stripFrontSpaces = collapseWhiteSpace && m_hasEndWhiteSpace;
 
     if (!style()->autoWrap() || floatMinWidth > floatMaxWidth)
         floatMinWidth = floatMaxWidth;
 
     // Compute our max widths by scanning the string for newlines.
     if (hasBreak) {
@@ skipping 191 matching lines @@
         // Terminate word boundary at bidi run boundary.
         if (run)
             j = std::min(j, run->stop() + 1);
         int wordLen = j - i;
         if (wordLen) {
             bool isSpace = (j < len) && c == spaceCharacter;
 
             // Non-zero only when kerning is enabled, in which case we measure words with their trailing
             // space, then subtract its width.
             float wordTrailingSpaceWidth = 0;
-            if (isSpace && (f.fontDescription().getTypesettingFeatures() & Kerning)) {
+            if (isSpace && (f.getFontDescription().getTypesettingFeatures() & Kerning)) {
                 ASSERT(textDirection >=0 && textDirection <= 1);
                 if (!cachedWordTrailingSpaceWidth[textDirection])
                     cachedWordTrailingSpaceWidth[textDirection] = f.width(constructTextRun(f, &spaceCharacter, 1, styleToUse, textDirection)) + wordSpacing;
                 wordTrailingSpaceWidth = cachedWordTrailingSpaceWidth[textDirection];
             }
 
             float w;
             if (wordTrailingSpaceWidth && isSpace) {
                 w = widthFromFont(f, i, wordLen + 1, leadWidth, currMaxWidth, textDirection, &fallbackFonts, &glyphBounds) - wordTrailingSpaceWidth;
             } else {
@@ skipping 83 matching lines @@
     if (!styleToUse.autoWrap())
         m_minWidth = m_maxWidth;
 
     if (styleToUse.whiteSpace() == PRE) {
         if (firstLine)
             m_firstLineMinWidth = m_maxWidth;
         m_lastLineLineMinWidth = currMaxWidth;
     }
 
     GlyphOverflow glyphOverflow;
-    glyphOverflow.setFromBounds(glyphBounds, f.fontMetrics().floatAscent(), f.fontMetrics().floatDescent(), m_maxWidth);
+    glyphOverflow.setFromBounds(glyphBounds, f.getFontMetrics().floatAscent(), f.getFontMetrics().floatDescent(), m_maxWidth);
     // We shouldn't change our mind once we "know".
     ASSERT(!m_knownToHaveNoOverflowAndNoFallbackFonts || (fallbackFonts.isEmpty() && glyphOverflow.isApproximatelyZero()));
     m_knownToHaveNoOverflowAndNoFallbackFonts = fallbackFonts.isEmpty() && glyphOverflow.isApproximatelyZero();
 
     clearPreferredLogicalWidthsDirty();
 }
 
 bool LayoutText::isAllCollapsibleWhitespace() const
 {
     unsigned length = textLength();
@@ skipping 369 matching lines @@
         return 0;
 
     float w;
     if (&f == &style()->font()) {
         if (!style()->preserveNewline() && !from && len == textLength()) {
             if (fallbackFonts) {
                 ASSERT(glyphBounds);
                 if (preferredLogicalWidthsDirty() || !m_knownToHaveNoOverflowAndNoFallbackFonts)
                     const_cast<LayoutText*>(this)->computePreferredLogicalWidths(0, *fallbackFonts, *glyphBounds);
                 else
-                    *glyphBounds = FloatRect(0, -f.fontMetrics().floatAscent(), m_maxWidth, f.fontMetrics().floatHeight());
+                    *glyphBounds = FloatRect(0, -f.getFontMetrics().floatAscent(), m_maxWidth, f.getFontMetrics().floatHeight());
                 w = m_maxWidth;
             } else {
                 w = maxLogicalWidth();
             }
         } else {
             w = widthFromFont(f, from, len, xPos.toFloat(), 0, textDirection, fallbackFonts, glyphBounds);
         }
     } else {
         TextRun run = constructTextRun(f, this, from, len, styleRef(), textDirection);
         run.setCharactersLength(textLength() - from);
@@ skipping 237 matching lines @@
     for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
         paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*box, invalidationReason);
         if (box->truncation() != cNoTruncation) {
             if (EllipsisBox* ellipsisBox = box->root().ellipsisBox())
                 paintInvalidationContainer.invalidateDisplayItemClientOnBacking(*ellipsisBox, invalidationReason);
         }
     }
 }
 
 } // namespace blink