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

third_party/WebKit/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.
  * Copyright (c) 2007, 2008, 2010 Google 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
@@ skipping 69 matching lines @@
 {
     m_fontDescription = other.m_fontDescription;
     m_fontFallbackList = other.m_fontFallbackList;
     m_canShapeWordByWord = other.m_canShapeWordByWord;
     m_shapeWordByWordComputed = other.m_shapeWordByWordComputed;
     return *this;
 }
 
 bool Font::operator==(const Font& other) const
 {
-    FontSelector* first = m_fontFallbackList ? m_fontFallbackList->fontSelector() : 0;
-    FontSelector* second = other.m_fontFallbackList ? other.m_fontFallbackList->fontSelector() : 0;
+    FontSelector* first = m_fontFallbackList ? m_fontFallbackList->getFontSelector() : 0;
+    FontSelector* second = other.m_fontFallbackList ? other.m_fontFallbackList->getFontSelector() : 0;
 
     return first == second
         && m_fontDescription == other.m_fontDescription
         && (m_fontFallbackList ? m_fontFallbackList->fontSelectorVersion() : 0) == (other.m_fontFallbackList ? other.m_fontFallbackList->fontSelectorVersion() : 0)
         && (m_fontFallbackList ? m_fontFallbackList->generation() : 0) == (other.m_fontFallbackList ? other.m_fontFallbackList->generation() : 0);
 }
 
 void Font::update(PassRefPtrWillBeRawPtr<FontSelector> fontSelector) const
 {
     // FIXME: It is pretty crazy that we are willing to just poke into a RefPtr, but it ends up
@@ skipping 209 matching lines @@
 
         const uint16_t* glyphs = m_buffer.glyphs(start);
         const float* offsets = m_buffer.offsets(start);
         std::copy(glyphs, glyphs + count, buffer.glyphs);
 
         if (m_rotation == NoRotation) {
             std::copy(offsets, offsets + (m_hasVerticalOffsets ? 2 * count : count), buffer.pos);
         } else {
             ASSERT(m_hasVerticalOffsets);
 
-            const float verticalBaselineXOffset = fontData->fontMetrics().floatAscent()
-                - fontData->fontMetrics().floatAscent(IdeographicBaseline);
+            const float verticalBaselineXOffset = fontData->getFontMetrics().floatAscent()
+                - fontData->getFontMetrics().floatAscent(IdeographicBaseline);
 
             // TODO(fmalita): why don't we apply this adjustment when building the glyph buffer?
             for (unsigned i = 0; i < 2 * count; i += 2) {
                 buffer.pos[i] = SkFloatToScalar(offsets[i] + verticalBaselineXOffset);
                 buffer.pos[i + 1] = SkFloatToScalar(offsets[i + 1]);
             }
         }
     }
 
     const GlyphBuffer& m_buffer;
@@ skipping 62 matching lines @@
 
     if (codePath(runInfo) != ComplexPath)
         return pixelSnappedSelectionRect(selectionRectForSimpleText(run, point, h, from, to, accountForGlyphBounds));
     return pixelSnappedSelectionRect(selectionRectForComplexText(run, point, h, from, to));
 }
 
 int Font::offsetForPosition(const TextRun& run, float x, bool includePartialGlyphs) const
 {
     FontCachePurgePreventer purgePreventer;
 
-    if (codePath(TextRunPaintInfo(run)) != ComplexPath && !fontDescription().getTypesettingFeatures())
+    if (codePath(TextRunPaintInfo(run)) != ComplexPath && !getFontDescription().getTypesettingFeatures())
         return offsetForPositionForSimpleText(run, x, includePartialGlyphs);
 
     return offsetForPositionForComplexText(run, x, includePartialGlyphs);
 }
 
 CodePath Font::codePath(const TextRunPaintInfo& runInfo) const
 {
 // TODO(eae): Disable the always use complex text feature on Android for now as
 // it caused a memory regression for webview. crbug.com/577306
 #if !OS(ANDROID)
     if (RuntimeEnabledFeatures::alwaysUseComplexTextEnabled()
         || LayoutTestSupport::alwaysUseComplexTextForTest()) {
         return ComplexPath;
     }
 #endif
 
     const TextRun& run = runInfo.run;
 
-    if (fontDescription().getTypesettingFeatures() && (runInfo.from || runInfo.to != run.length()))
+    if (getFontDescription().getTypesettingFeatures() && (runInfo.from || runInfo.to != run.length()))
         return ComplexPath;
 
     if (m_fontDescription.featureSettings() && m_fontDescription.featureSettings()->size() > 0)
         return ComplexPath;
 
     if (m_fontDescription.isVerticalBaseline())
         return ComplexPath;
 
     if (m_fontDescription.widthVariant() != RegularWidth)
         return ComplexPath;
 
-    if (run.length() > 1 && fontDescription().getTypesettingFeatures())
+    if (run.length() > 1 && getFontDescription().getTypesettingFeatures())
         return ComplexPath;
 
     // FIXME: This really shouldn't be needed but for some reason the
     // TextRendering setting doesn't propagate to typesettingFeatures in time
     // for the prefs width calculation.
-    if (fontDescription().textRendering() == OptimizeLegibility || fontDescription().textRendering() == GeometricPrecision)
+    if (getFontDescription().textRendering() == OptimizeLegibility || getFontDescription().textRendering() == GeometricPrecision)
         return ComplexPath;
 
     if (run.is8Bit())
         return SimplePath;
 
     // Start from 0 since drawing and highlighting also measure the characters before run->from.
     return Character::characterRangeCodePath(run.characters16(), run.length());
 }
 
 bool Font::canShapeWordByWord() const
 {
     if (!m_shapeWordByWordComputed) {
         m_canShapeWordByWord = computeCanShapeWordByWord();
         m_shapeWordByWordComputed = true;
     }
     return m_canShapeWordByWord;
 };
 
 bool Font::computeCanShapeWordByWord() const
 {
-    if (!fontDescription().getTypesettingFeatures())
+    if (!getFontDescription().getTypesettingFeatures())
         return true;
 
     const FontPlatformData& platformData = primaryFont()->platformData();
-    TypesettingFeatures features = fontDescription().getTypesettingFeatures();
+    TypesettingFeatures features = getFontDescription().getTypesettingFeatures();
     return !platformData.hasSpaceInLigaturesOrKerning(features);
 };
 
 void Font::willUseFontData(UChar32 character) const
 {
-    const FontFamily& family = fontDescription().family();
-    if (m_fontFallbackList && m_fontFallbackList->fontSelector() && !family.familyIsEmpty())
-        m_fontFallbackList->fontSelector()->willUseFontData(fontDescription(), family.family(), character);
+    const FontFamily& family = getFontDescription().family();
+    if (m_fontFallbackList && m_fontFallbackList->getFontSelector() && !family.familyIsEmpty())
+        m_fontFallbackList->getFontSelector()->willUseFontData(getFontDescription(), family.family(), character);
 }
 
 static inline GlyphData glyphDataForNonCJKCharacterWithGlyphOrientation(UChar32 character, bool isUpright, GlyphData& data, unsigned pageNumber)
 {
     if (isUpright) {
         RefPtr<SimpleFontData> uprightFontData = data.fontData->uprightOrientationFontData();
         GlyphPageTreeNode* uprightNode = GlyphPageTreeNode::getNormalRootChild(uprightFontData.get(), pageNumber);
         GlyphPage* uprightPage = uprightNode->page();
         if (uprightPage) {
             GlyphData uprightData = uprightPage->glyphDataForCharacter(character);
@@ skipping 200 matching lines @@
 
     GlyphData markGlyphData;
     if (!getEmphasisMarkGlyphData(mark, markGlyphData))
         return 0;
 
     const SimpleFontData* markFontData = markGlyphData.fontData;
     ASSERT(markFontData);
     if (!markFontData)
         return 0;
 
-    return markFontData->fontMetrics().ascent();
+    return markFontData->getFontMetrics().ascent();
 }
 
 int Font::emphasisMarkDescent(const AtomicString& mark) const
 {
     FontCachePurgePreventer purgePreventer;
 
     GlyphData markGlyphData;
     if (!getEmphasisMarkGlyphData(mark, markGlyphData))
         return 0;
 
     const SimpleFontData* markFontData = markGlyphData.fontData;
     ASSERT(markFontData);
     if (!markFontData)
         return 0;
 
-    return markFontData->fontMetrics().descent();
+    return markFontData->getFontMetrics().descent();
 }
 
 int Font::emphasisMarkHeight(const AtomicString& mark) const
 {
     FontCachePurgePreventer purgePreventer;
 
     GlyphData markGlyphData;
     if (!getEmphasisMarkGlyphData(mark, markGlyphData))
         return 0;
 
     const SimpleFontData* markFontData = markGlyphData.fontData;
     ASSERT(markFontData);
     if (!markFontData)
         return 0;
 
-    return markFontData->fontMetrics().height();
+    return markFontData->getFontMetrics().height();
 }
 
 float Font::floatWidthForComplexText(const TextRun& run, HashSet<const SimpleFontData*>* fallbackFonts, FloatRect* glyphBounds) const
 {
     CachingWordShaper shaper(m_fontFallbackList->shapeCache(m_fontDescription));
     float width = shaper.width(this, run, fallbackFonts, glyphBounds);
     return width;
 }
 
 // Return the code point index for the given |x| offset into the text run.
@@ skipping 90 matching lines @@
 {
     return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const
 {
     return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 } // namespace blink