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

third_party/WebKit/Source/platform/fonts/FontDescription.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.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 117 matching lines @@
         FamilyDescription(GenericFamilyType genericFamily, const FontFamily& family)
             : genericFamily(genericFamily)
             , family(family)
         {
         }
         GenericFamilyType genericFamily;
         FontFamily family;
     };
 
     const FontFamily& family() const { return m_familyList; }
-    FamilyDescription familyDescription() const { return FamilyDescription(genericFamily(), family()); }
+    FamilyDescription getFamilyDescription() const { return FamilyDescription(genericFamily(), family()); }
     FontFamily& firstFamily() { return m_familyList; }
-    Size size() const { return Size(keywordSize(), specifiedSize(), isAbsoluteSize()); }
+    Size getSize() const { return Size(keywordSize(), specifiedSize(), isAbsoluteSize()); }
     float specifiedSize() const { return m_specifiedSize; }
     float computedSize() const { return m_computedSize; }
     float adjustedSize() const { return m_adjustedSize; }
     float sizeAdjust() const { return m_sizeAdjust; }
     bool hasSizeAdjust() const { return m_sizeAdjust != FontSizeAdjustNone; }
     FontStyle style() const { return static_cast<FontStyle>(m_fields.m_style); }
     int computedPixelSize() const { return int(m_computedSize + 0.5f); }
     FontVariant variant() const { return static_cast<FontVariant>(m_fields.m_variant); }
     bool isAbsoluteSize() const { return m_fields.m_isAbsoluteSize; }
     FontWeight weight() const { return static_cast<FontWeight>(m_fields.m_weight); }
     FontStretch stretch() const { return static_cast<FontStretch>(m_fields.m_stretch); }
     static FontWeight lighterWeight(FontWeight);
     static FontWeight bolderWeight(FontWeight);
     static Size largerSize(const Size&);
     static Size smallerSize(const Size&);
     GenericFamilyType genericFamily() const { return static_cast<GenericFamilyType>(m_fields.m_genericFamily); }
 
     // only use fixed default size when there is only one font family, and that family is "monospace"
     bool isMonospace() const
     {
         return genericFamily() == MonospaceFamily && !family().next() && family().family() == FontFamilyNames::webkit_monospace;
     }
-    Kerning kerning() const { return static_cast<Kerning>(m_fields.m_kerning); }
+    Kerning getKerning() const { return static_cast<Kerning>(m_fields.m_kerning); }
     VariantLigatures variantLigatures() const;
     LigaturesState commonLigaturesState() const { return static_cast<LigaturesState>(m_fields.m_commonLigaturesState); }
     LigaturesState discretionaryLigaturesState() const { return static_cast<LigaturesState>(m_fields.m_discretionaryLigaturesState); }
     LigaturesState historicalLigaturesState() const { return static_cast<LigaturesState>(m_fields.m_historicalLigaturesState); }
     LigaturesState contextualLigaturesState() const { return static_cast<LigaturesState>(m_fields.m_contextualLigaturesState); }
     unsigned keywordSize() const { return m_fields.m_keywordSize; }
     FontSmoothingMode fontSmoothing() const { return static_cast<FontSmoothingMode>(m_fields.m_fontSmoothing); }
     TextRenderingMode textRendering() const { return static_cast<TextRenderingMode>(m_fields.m_textRendering); }
     UScriptCode script() const { return static_cast<UScriptCode>(m_fields.m_script); }
     const AtomicString& locale(bool includeDefault = true) const;
@@ skipping 38 matching lines @@
         m_locale = locale;
         m_fields.m_script = localeToScriptCodeForFontSelection(locale);
     }
     void setSyntheticBold(bool syntheticBold) { m_fields.m_syntheticBold = syntheticBold; }
     void setSyntheticItalic(bool syntheticItalic) { m_fields.m_syntheticItalic = syntheticItalic; }
     void setFeatureSettings(PassRefPtr<FontFeatureSettings> settings) { m_featureSettings = settings; }
     void setTraits(FontTraits);
     void setWordSpacing(float s) { m_wordSpacing = s; }
     void setLetterSpacing(float s) { m_letterSpacing = s; updateTypesettingFeatures(); }
 
-    TypesettingFeatures typesettingFeatures() const { return static_cast<TypesettingFeatures>(m_fields.m_typesettingFeatures); }
+    TypesettingFeatures getTypesettingFeatures() const { return static_cast<TypesettingFeatures>(m_fields.m_typesettingFeatures); }
 
     static void setSubpixelPositioning(bool b) { s_useSubpixelTextPositioning = b; }
     static bool subpixelPositioning() { return s_useSubpixelTextPositioning; }
 
     static void setDefaultTypesettingFeatures(TypesettingFeatures);
     static TypesettingFeatures defaultTypesettingFeatures();
 
     unsigned styleHashWithoutFamilyList() const;
     unsigned bitmapFields() const { return m_fieldsAsUnsigned[0]; }
     unsigned auxiliaryBitmapFields() const { return m_fieldsAsUnsigned[1]; }
@@ skipping 74 matching lines @@
         && m_letterSpacing == other.m_letterSpacing
         && m_wordSpacing == other.m_wordSpacing
         && m_fieldsAsUnsigned[0] == other.m_fieldsAsUnsigned[0]
         && m_fieldsAsUnsigned[1] == other.m_fieldsAsUnsigned[1]
         && m_featureSettings == other.m_featureSettings;
 }
 
 } // namespace blink
 
 #endif