Rename enums/functions that collide in chromium style in platform/

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 383 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().typesettingFeatures())
+    if (codePath(TextRunPaintInfo(run)) != ComplexPath && !fontDescription().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().typesettingFeatures() && (runInfo.from || runInfo.to != run.length()))
+    if (fontDescription().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().typesettingFeatures())
+    if (run.length() > 1 && fontDescription().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)
         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().typesettingFeatures())
+    if (!fontDescription().getTypesettingFeatures())
         return true;
 
     const FontPlatformData& platformData = primaryFont()->platformData();
-    TypesettingFeatures features = fontDescription().typesettingFeatures();
+    TypesettingFeatures features = fontDescription().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);
 }
 
@@ skipping 347 matching lines @@
 {
     return m_fontFallbackList && m_fontFallbackList->loadingCustomFonts();
 }
 
 bool Font::isFallbackValid() const
 {
     return !m_fontFallbackList || m_fontFallbackList->isValid();
 }
 
 } // namespace blink