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

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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 859 matching lines @@
     --gDelayUpdateScrollInfo;
     ASSERT(gDelayUpdateScrollInfo >= 0);
     if (gDelayUpdateScrollInfo == 0) {
         ASSERT(gDelayedUpdateScrollInfoSet);
 
         OwnPtr<DelayedUpdateScrollInfoSet> infoSet(adoptPtr(gDelayedUpdateScrollInfoSet));
         gDelayedUpdateScrollInfoSet = nullptr;
 
         for (auto* block : *infoSet) {
             if (block->hasOverflowClip()) {
-                childrenMarkedForRelayout |= block->layer()->scrollableArea()->updateAfterLayout(layoutScope);
+                childrenMarkedForRelayout |= block->layer()->getScrollableArea()->updateAfterLayout(layoutScope);
             }
         }
     }
     return childrenMarkedForRelayout;
 }
 
 void LayoutBlock::updateScrollInfoAfterLayout()
 {
     if (hasOverflowClip()) {
         if (style()->isFlippedBlocksWritingMode()) {
             // FIXME: https://bugs.webkit.org/show_bug.cgi?id=97937
             // Workaround for now. We cannot delay the scroll info for overflow
             // for items with opposite writing directions, as the contents needs
             // to overflow in that direction
-            layer()->scrollableArea()->updateAfterLayout();
+            layer()->getScrollableArea()->updateAfterLayout();
             return;
         }
 
         if (gDelayUpdateScrollInfo)
             gDelayedUpdateScrollInfoSet->add(this);
         else
-            layer()->scrollableArea()->updateAfterLayout();
+            layer()->getScrollableArea()->updateAfterLayout();
     }
 }
 
 void LayoutBlock::layout()
 {
     LayoutAnalyzer::Scope analyzer(*this);
 
     bool needsScrollAnchoring = RuntimeEnabledFeatures::scrollAnchoringEnabled() && hasOverflowClip();
     if (needsScrollAnchoring)
-        scrollableArea()->scrollAnchor().save();
+        getScrollableArea()->scrollAnchor().save();
 
     // Table cells call layoutBlock directly, so don't add any logic here.  Put code into
     // layoutBlock().
     layoutBlock(false);
 
     // It's safe to check for control clip here, since controls can never be table cells.
     // If we have a lightweight clip, there can never be any overflow from children.
     if (hasControlClip() && m_overflow)
         clearLayoutOverflow();
 
     invalidateBackgroundObscurationStatus();
 
     if (needsScrollAnchoring)
-        scrollableArea()->scrollAnchor().restore();
+        getScrollableArea()->scrollAnchor().restore();
 
     m_heightAvailableToChildrenChanged = false;
 }
 
 bool LayoutBlock::widthAvailableToChildrenHasChanged()
 {
     // TODO(robhogan): Does m_widthAvailableToChildrenChanged always get reset when it needs to?
     bool widthAvailableToChildrenHasChanged = m_widthAvailableToChildrenChanged;
     m_widthAvailableToChildrenChanged = false;
 
@@ skipping 659 matching lines @@
         afterLowest->markDirty();
         afterLowest = afterLowest->prevRootBox();
     }
 }
 
 bool LayoutBlock::isPointInOverflowControl(HitTestResult& result, const LayoutPoint& locationInContainer, const LayoutPoint& accumulatedOffset) const
 {
     if (!scrollsOverflow())
         return false;
 
-    return layer()->scrollableArea()->hitTestOverflowControls(result, roundedIntPoint(locationInContainer - toLayoutSize(accumulatedOffset)));
+    return layer()->getScrollableArea()->hitTestOverflowControls(result, roundedIntPoint(locationInContainer - toLayoutSize(accumulatedOffset)));
 }
 
 Node* LayoutBlock::nodeForHitTest() const
 {
     // If we are in the margins of block elements that are part of a
     // continuation we're actually still inside the enclosing element
     // that was split. Use the appropriate inner node.
     return isAnonymousBlockContinuation() ? continuation()->node() : node();
 }
 
@@ skipping 301 matching lines @@
 
     if (hasOverflowClip())
         offset += LayoutSize(scrolledContentOffset());
 
     offset = flipForWritingMode(offset);
 }
 
 int LayoutBlock::columnGap() const
 {
     if (style()->hasNormalColumnGap())
-        return style()->fontDescription().computedPixelSize(); // "1em" is recommended as the normal gap setting. Matches <p> margins.
+        return style()->getFontDescription().computedPixelSize(); // "1em" is recommended as the normal gap setting. Matches <p> margins.
     return static_cast<int>(style()->columnGap());
 }
 
 void LayoutBlock::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
 {
     // Layout-contained elements don't consider their contents for preferred sizing.
     if (style()->containsLayout())
         return;
 
     if (childrenInline()) {
@@ skipping 237 matching lines @@
         if (baselinePos != -1)
             return beforeMarginInLineDirection(direction) + baselinePos;
 
         return LayoutBox::baselinePosition(baselineType, firstLine, direction, linePositionMode);
     }
 
     // If we're not replaced, we'll only get called with PositionOfInteriorLineBoxes.
     // Note that inline-block counts as replaced here.
     ASSERT(linePositionMode == PositionOfInteriorLineBoxes);
 
-    const FontMetrics& fontMetrics = style(firstLine)->fontMetrics();
+    const FontMetrics& fontMetrics = style(firstLine)->getFontMetrics();
     return fontMetrics.ascent(baselineType) + (lineHeight(firstLine, direction, linePositionMode) - fontMetrics.height()) / 2;
 }
 
 LayoutUnit LayoutBlock::minLineHeightForReplacedObject(bool isFirstLine, LayoutUnit replacedHeight) const
 {
     if (!document().inNoQuirksMode() && replacedHeight)
         return replacedHeight;
 
     return std::max<LayoutUnit>(replacedHeight, lineHeight(isFirstLine, isHorizontalWritingMode() ? HorizontalLine : VerticalLine, PositionOfInteriorLineBoxes));
 }
 
 int LayoutBlock::firstLineBoxBaseline() const
 {
     if (isWritingModeRoot() && !isRubyRun())
         return -1;
 
     if (childrenInline()) {
         if (firstLineBox())
-            return firstLineBox()->logicalTop() + style(true)->fontMetrics().ascent(firstRootBox()->baselineType());
+            return firstLineBox()->logicalTop() + style(true)->getFontMetrics().ascent(firstRootBox()->baselineType());
         return -1;
     }
     for (LayoutBox* curr = firstChildBox(); curr; curr = curr->nextSiblingBox()) {
         if (!curr->isFloatingOrOutOfFlowPositioned()) {
             int result = curr->firstLineBoxBaseline();
             if (result != -1)
                 return curr->logicalTop() + result; // Translate to our coordinate space.
         }
     }
     return -1;
@@ skipping 13 matching lines @@
     if ((!style()->isOverflowVisible() && !shouldIgnoreOverflowPropertyForInlineBlockBaseline()) || style()->containsLayout()) {
         // We are not calling LayoutBox::baselinePosition here because the caller should add the margin-top/margin-right, not us.
         return lineDirection == HorizontalLine ? size().height() + marginBottom() : size().width() + marginLeft();
     }
 
     if (isWritingModeRoot() && !isRubyRun())
         return -1;
 
     if (childrenInline()) {
         if (!firstLineBox() && hasLineIfEmpty()) {
-            const FontMetrics& fontMetrics = firstLineStyle()->fontMetrics();
+            const FontMetrics& fontMetrics = firstLineStyle()->getFontMetrics();
             return fontMetrics.ascent()
                 + (lineHeight(true, lineDirection, PositionOfInteriorLineBoxes) - fontMetrics.height()) / 2
                 + (lineDirection == HorizontalLine ? borderTop() + paddingTop() : borderRight() + paddingRight());
         }
         if (lastLineBox())
-            return lastLineBox()->logicalTop() + style(lastLineBox() == firstLineBox())->fontMetrics().ascent(lastRootBox()->baselineType());
+            return lastLineBox()->logicalTop() + style(lastLineBox() == firstLineBox())->getFontMetrics().ascent(lastRootBox()->baselineType());
         return -1;
     }
 
     bool haveNormalFlowChild = false;
     for (LayoutBox* curr = lastChildBox(); curr; curr = curr->previousSiblingBox()) {
         if (!curr->isFloatingOrOutOfFlowPositioned()) {
             haveNormalFlowChild = true;
             int result = curr->inlineBlockBaseline(lineDirection);
             if (result != -1)
                 return curr->logicalTop() + result; // Translate to our coordinate space.
         }
     }
     if (!haveNormalFlowChild && hasLineIfEmpty()) {
-        const FontMetrics& fontMetrics = firstLineStyle()->fontMetrics();
+        const FontMetrics& fontMetrics = firstLineStyle()->getFontMetrics();
         return fontMetrics.ascent()
             + (lineHeight(true, lineDirection, PositionOfInteriorLineBoxes) - fontMetrics.height()) / 2
             + (lineDirection == HorizontalLine ? borderTop() + paddingTop() : borderRight() + paddingRight());
     }
     return -1;
 }
 
 LayoutBlock* LayoutBlock::enclosingFirstLineStyleBlock() const
 {
     LayoutBlock* firstLineBlock = const_cast<LayoutBlock*>(this);
@@ skipping 527 matching lines @@
     clearSelfNeedsOverflowRecalcAfterStyleChange();
     // If the current block needs layout, overflow will be recalculated during
     // layout time anyway. We can safely exit here.
     if (needsLayout())
         return false;
 
     LayoutUnit oldClientAfterEdge = hasOverflowModel() ? m_overflow->layoutClientAfterEdge() : clientLogicalBottom();
     computeOverflow(oldClientAfterEdge, true);
 
     if (hasOverflowClip())
-        layer()->scrollableArea()->updateAfterOverflowRecalc();
+        layer()->getScrollableArea()->updateAfterOverflowRecalc();
 
     return !hasOverflowClip();
 }
 
 // Called when a positioned object moves but doesn't necessarily change size.  A simplified layout is attempted
 // that just updates the object's position. If the size does change, the object remains dirty.
 bool LayoutBlock::tryLayoutDoingPositionedMovementOnly()
 {
     LayoutUnit oldWidth = logicalWidth();
     LogicalExtentComputedValues computedValues;
@@ skipping 47 matching lines @@
 void LayoutBlock::showLineTreeAndMark(const InlineBox* markedBox1, const char* markedLabel1, const InlineBox* markedBox2, const char* markedLabel2, const LayoutObject* obj) const
 {
     showLayoutObject();
     for (const RootInlineBox* root = firstRootBox(); root; root = root->nextRootBox())
         root->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2, obj, 1);
 }
 
 #endif
 
 } // namespace blink