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

third_party/WebKit/Source/platform/fonts/shaping/HarfBuzzShaper.cpp

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 BlackBerry Limited. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 98 matching lines @@
             character = zeroWidthSpaceCharacter;
 
         U16_APPEND(destination, *destinationLength, length, character, error);
         ASSERT_UNUSED(error, !error);
     }
 }
 
 HarfBuzzShaper::HarfBuzzShaper(const Font* font, const TextRun& run)
     : Shaper(font, run)
     , m_normalizedBufferLength(0)
-    , m_wordSpacingAdjustment(font->fontDescription().wordSpacing())
-    , m_letterSpacing(font->fontDescription().letterSpacing())
+    , m_wordSpacingAdjustment(font->getFontDescription().wordSpacing())
+    , m_letterSpacing(font->getFontDescription().letterSpacing())
     , m_expansionOpportunityCount(0)
 {
     m_normalizedBuffer = adoptArrayPtr(new UChar[m_textRun.length() + 1]);
     normalizeCharacters(m_textRun, m_textRun.length(), m_normalizedBuffer.get(), &m_normalizedBufferLength);
     setExpansion(m_textRun.expansion());
     setFontFeatures();
 }
 
 float HarfBuzzShaper::nextExpansionPerOpportunity()
 {
@@ skipping 33 matching lines @@
         m_expansionPerOpportunity = 0;
 }
 
 static inline hb_feature_t createFeature(uint8_t c1, uint8_t c2, uint8_t c3, uint8_t c4, uint32_t value = 0)
 {
     return { HB_TAG(c1, c2, c3, c4), value, 0 /* start */, static_cast<unsigned>(-1) /* end */ };
 }
 
 void HarfBuzzShaper::setFontFeatures()
 {
-    const FontDescription& description = m_font->fontDescription();
+    const FontDescription& description = m_font->getFontDescription();
 
     static hb_feature_t noKern = createFeature('k', 'e', 'r', 'n');
     static hb_feature_t noVkrn = createFeature('v', 'k', 'r', 'n');
     switch (description.getKerning()) {
     case FontDescription::NormalKerning:
         // kern/vkrn are enabled by default
         break;
     case FontDescription::NoneKerning:
         m_features.append(description.isVerticalAnyUpright() ? noVkrn : noKern);
         break;
@@ skipping 140 matching lines @@
     const FontPlatformData* platformData = &(currentFont->platformData());
     HarfBuzzFace* face = platformData->harfBuzzFace();
     if (!face) {
         WTF_LOG_ERROR("Could not create HarfBuzzFace from FontPlatformData.");
         return false;
     }
 
     hb_buffer_set_language(harfBuzzBuffer, language);
     hb_buffer_set_script(harfBuzzBuffer, ICUScriptToHBScript(currentRunScript));
     hb_buffer_set_direction(harfBuzzBuffer, TextDirectionToHBDirection(m_textRun.direction(),
-        m_font->fontDescription().orientation(), currentFont));
+        m_font->getFontDescription().orientation(), currentFont));
 
     addToHarfBuzzBufferInternal(harfBuzzBuffer,
-        m_font->fontDescription(), m_normalizedBuffer.get(), m_normalizedBufferLength,
+        m_font->getFontDescription(), m_normalizedBuffer.get(), m_normalizedBufferLength,
         startIndex, numCharacters);
 
     HarfBuzzScopedPtr<hb_font_t> harfBuzzFont(face->createFont(currentFontRangeFrom, currentFontRangeTo), hb_font_destroy);
     hb_shape(harfBuzzFont.get(), harfBuzzBuffer, m_features.isEmpty() ? 0 : m_features.data(), m_features.size());
 
     return true;
 }
 
 bool HarfBuzzShaper::extractShapeResults(hb_buffer_t* harfBuzzBuffer,
     ShapeResult* shapeResult,
@@ skipping 103 matching lines @@
         // whole grapheme. We do not append it here. For the next glyph we
         // encounter, atChange will be true, and the characters corresponding to
         // the grapheme will be added to the TODO queue again, attempting to
         // shape the whole grapheme with the next font.
         // When we're getting here with the last resort font, we have no other
         // choice than adding boxes to the ShapeResult.
         if ((currentClusterResult == NotDef && numCharacters) || isLastResort) {
             // Here we need to specify glyph positions.
             OwnPtr<ShapeResult::RunInfo> run = adoptPtr(new ShapeResult::RunInfo(currentFont,
                 TextDirectionToHBDirection(m_textRun.direction(),
-                m_font->fontDescription().orientation(), currentFont),
+                m_font->getFontDescription().orientation(), currentFont),
                 ICUScriptToHBScript(currentRunScript),
                 startIndex,
                 numGlyphsToInsert, numCharacters));
             insertRunIntoShapeResult(shapeResult, run.release(), lastChangePosition, numGlyphsToInsert, harfBuzzBuffer);
         }
         lastChangePosition = glyphIndex;
     }
     return true;
 }
 
@@ skipping 43 matching lines @@
 {
     m_holesQueue.append(HolesQueueItem(action, startIndex, numCharacters));
 }
 
 PassRefPtr<ShapeResult> HarfBuzzShaper::shapeResult()
 {
     RefPtr<ShapeResult> result = ShapeResult::create(m_font,
         m_normalizedBufferLength, m_textRun.direction());
     HarfBuzzScopedPtr<hb_buffer_t> harfBuzzBuffer(hb_buffer_create(), hb_buffer_destroy);
 
-    const FontDescription& fontDescription = m_font->fontDescription();
+    const FontDescription& fontDescription = m_font->getFontDescription();
     const String& localeString = fontDescription.locale();
     CString locale = localeString.latin1();
     const hb_language_t language = hb_language_from_string(locale.data(), locale.length());
 
     RunSegmenter::RunSegmenterRange segmentRange = {
         0,
         0,
         USCRIPT_INVALID_CODE,
         OrientationIterator::OrientationInvalid,
         SmallCapsIterator::SmallCapsSameCase,
         FontFallbackPriority::Invalid };
     RunSegmenter runSegmenter(
         m_normalizedBuffer.get(),
         m_normalizedBufferLength,
-        m_font->fontDescription().orientation(),
+        m_font->getFontDescription().orientation(),
         fontDescription.variant());
 
     Vector<UChar32> fallbackCharsHint;
 
     // TODO: Check whether this treatAsZerowidthspace from the previous script
     // segmentation plays a role here, does the new scriptRuniterator handle that correctly?
     while (runSegmenter.consume(&segmentRange)) {
         RefPtr<FontFallbackIterator> fallbackIterator =
             m_font->createFontFallbackIterator(
             segmentRange.fontFallbackPriority);
@@ skipping 40 matching lines @@
             // these features are enabled but when a user agent simulates small capitals, it must not attempt to
             // simulate alternates for codepoints which are considered caseless."
             const SimpleFontData* smallcapsAdjustedFont = segmentRange.smallCapsBehavior == SmallCapsIterator::SmallCapsUppercaseNeeded
                 ? currentFont->smallCapsFontData(fontDescription).get()
                 : currentFont;
 
             // Compatibility with SimpleFontData approach of keeping a flag for overriding drawing direction.
             // TODO: crbug.com/506224 This should go away in favor of storing that information elsewhere, for example in
             // ShapeResult.
             const SimpleFontData* directionAndSmallCapsAdjustedFont = fontDataAdjustedForOrientation(smallcapsAdjustedFont,
-                m_font->fontDescription().orientation(),
+                m_font->getFontDescription().orientation(),
                 segmentRange.renderOrientation);
 
             if (!shapeRange(harfBuzzBuffer.get(),
                 currentQueueItem.m_startIndex,
                 currentQueueItem.m_numCharacters,
                 directionAndSmallCapsAdjustedFont,
                 currentFontRangeFrom,
                 currentFontRangeTo,
                 segmentRange.script,
                 language))
@@ skipping 25 matching lines @@
 
     const SimpleFontData* currentFontData = run->m_fontData.get();
     const hb_glyph_info_t* glyphInfos = hb_buffer_get_glyph_infos(harfBuzzBuffer, 0);
     const hb_glyph_position_t* glyphPositions = hb_buffer_get_glyph_positions(harfBuzzBuffer, 0);
     const unsigned startCluster = HB_DIRECTION_IS_FORWARD(hb_buffer_get_direction(harfBuzzBuffer))
         ? glyphInfos[startGlyph].cluster : glyphInfos[startGlyph + numGlyphs - 1].cluster;
 
     float totalAdvance = 0.0f;
     FloatPoint glyphOrigin;
     float offsetX, offsetY;
-    float* directionOffset = m_font->fontDescription().isVerticalAnyUpright() ? &offsetY : &offsetX;
+    float* directionOffset = m_font->getFontDescription().isVerticalAnyUpright() ? &offsetY : &offsetX;
     bool hasVerticalOffsets = !HB_DIRECTION_IS_HORIZONTAL(run->m_direction);
 
     // HarfBuzz returns result in visual order, no need to flip for RTL.
     for (unsigned i = 0; i < numGlyphs; ++i) {
         bool runEnd = i + 1 == numGlyphs;
         uint16_t glyph = glyphInfos[startGlyph + i].codepoint;
         offsetX = harfBuzzPositionToFloat(glyphPositions[startGlyph + i].x_offset);
         offsetY = -harfBuzzPositionToFloat(glyphPositions[startGlyph + i].y_offset);
 
         // One out of x_advance and y_advance is zero, depending on
@@ skipping 138 matching lines @@
     }
 
     // Don't need to check m_textRun.allowsTrailingExpansion() since it's covered by !m_expansionOpportunityCount above
     spacing += nextExpansionPerOpportunity();
     m_isAfterExpansion = true;
     return spacing;
 }
 
 
 } // namespace blink