Add DISABLE_CFI_PERF attribute on the methods with CFI checks disabled.

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. 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
@@ skipping 419 matching lines @@
         child->layoutIfNeeded();
         ASSERT(!child->needsLayout());
         child = child->nextSibling();
     }
     invalidateBackgroundObscurationStatus();
     clearNeedsLayout();
 }
 
 // More IE extensions.  clientWidth and clientHeight represent the interior of an object
 // excluding border and scrollbar.
+DISABLE_CFI_PERF
 LayoutUnit LayoutBox::clientWidth() const
 {
     return m_frameRect.width() - borderLeft() - borderRight() - verticalScrollbarWidth();
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutBox::clientHeight() const
 {
     return m_frameRect.height() - borderTop() - borderBottom() - horizontalScrollbarHeight();
 }
 
 int LayoutBox::pixelSnappedClientWidth() const
 {
     return snapSizeToPixel(clientWidth(), location().x() + clientLeft());
 }
 
+DISABLE_CFI_PERF
 int LayoutBox::pixelSnappedClientHeight() const
 {
     return snapSizeToPixel(clientHeight(), location().y() + clientTop());
 }
 
 int LayoutBox::pixelSnappedOffsetWidth(const Element*) const
 {
     return snapSizeToPixel(offsetWidth(), location().x() + clientLeft());
 }
 
@@ skipping 638 matching lines @@
 #if ENABLE(ASSERT)
         SetLayoutNeededForbiddenScope layoutForbiddenScope(const_cast<LayoutBox&>(*this));
 #endif
         const_cast<LayoutBox*>(this)->computePreferredLogicalWidths();
         ASSERT(!preferredLogicalWidthsDirty());
     }
 
     return m_minPreferredLogicalWidth;
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutBox::maxPreferredLogicalWidth() const
 {
     if (preferredLogicalWidthsDirty()) {
 #if ENABLE(ASSERT)
         SetLayoutNeededForbiddenScope layoutForbiddenScope(const_cast<LayoutBox&>(*this));
 #endif
         const_cast<LayoutBox*>(this)->computePreferredLogicalWidths();
         ASSERT(!preferredLogicalWidthsDirty());
     }
 
@@ skipping 368 matching lines @@
         if (childLocalRect.maxY() > childBox->size().height() || childLocalRect.maxX() > childBox->size().width())
             continue;
         if (childBox->backgroundIsKnownToBeOpaqueInRect(childLocalRect))
             return true;
         if (childBox->foregroundIsKnownToBeOpaqueInRect(childLocalRect, maxDepthToTest - 1))
             return true;
     }
     return false;
 }
 
+DISABLE_CFI_PERF
 bool LayoutBox::computeBackgroundIsKnownToBeObscured() const
 {
     if (scrollsOverflow())
         return false;
     // Test to see if the children trivially obscure the background.
     if (!styleRef().hasBackground())
         return false;
     // Root background painting is special.
     if (isLayoutView())
         return false;
@@ skipping 744 matching lines @@
             // Make sure to compute the autosized width.
             if (itemMarker->needsLayout())
                 itemMarker->layout();
             maxWidth = std::max<float>(maxWidth, toLayoutListMarker(itemMarker)->logicalWidth().toFloat());
             break;
         }
     }
     return maxWidth;
 }
 
+DISABLE_CFI_PERF
 void LayoutBox::computeLogicalWidth(LogicalExtentComputedValues& computedValues) const
 {
     computedValues.m_extent = style()->containsSize() ? borderAndPaddingLogicalWidth() : logicalWidth();
     computedValues.m_position = logicalLeft();
     computedValues.m_margins.m_start = marginStart();
     computedValues.m_margins.m_end = marginEnd();
 
     if (isOutOfFlowPositioned()) {
         computePositionedLogicalWidth(computedValues);
         return;
@@ skipping 85 matching lines @@
 LayoutUnit LayoutBox::fillAvailableMeasure(LayoutUnit availableLogicalWidth, LayoutUnit& marginStart, LayoutUnit& marginEnd) const
 {
     ASSERT(availableLogicalWidth >= 0);
     marginStart = minimumValueForLength(style()->marginStart(), availableLogicalWidth);
     marginEnd = minimumValueForLength(style()->marginEnd(), availableLogicalWidth);
     LayoutUnit available = availableLogicalWidth - marginStart - marginEnd;
     available = std::max(available, LayoutUnit());
     return available;
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutBox::computeIntrinsicLogicalWidthUsing(const Length& logicalWidthLength, LayoutUnit availableLogicalWidth, LayoutUnit borderAndPadding) const
 {
     if (logicalWidthLength.type() == FillAvailable)
         return std::max(borderAndPadding, fillAvailableMeasure(availableLogicalWidth));
 
     LayoutUnit minLogicalWidth;
     LayoutUnit maxLogicalWidth;
     computeIntrinsicLogicalWidths(minLogicalWidth, maxLogicalWidth);
 
     if (logicalWidthLength.type() == MinContent)
         return minLogicalWidth + borderAndPadding;
 
     if (logicalWidthLength.type() == MaxContent)
         return maxLogicalWidth + borderAndPadding;
 
     if (logicalWidthLength.type() == FitContent) {
         minLogicalWidth += borderAndPadding;
         maxLogicalWidth += borderAndPadding;
         return std::max(minLogicalWidth, std::min(maxLogicalWidth, fillAvailableMeasure(availableLogicalWidth)));
     }
 
     ASSERT_NOT_REACHED();
     return LayoutUnit();
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutBox::computeLogicalWidthUsing(SizeType widthType, const Length& logicalWidth, LayoutUnit availableLogicalWidth, const LayoutBlock* cb) const
 {
     ASSERT(widthType == MinSize || widthType == MainOrPreferredSize || !logicalWidth.isAuto());
     if (widthType == MinSize && logicalWidth.isAuto())
         return adjustBorderBoxLogicalWidthForBoxSizing(0);
 
     if (!logicalWidth.isIntrinsicOrAuto()) {
         // FIXME: If the containing block flow is perpendicular to our direction we need to use the available logical height instead.
         return adjustBorderBoxLogicalWidthForBoxSizing(valueForLength(logicalWidth, availableLogicalWidth));
     }
@@ skipping 179 matching lines @@
             marginStart = availableWidth - childWidth - marginEnd;
             return;
         }
     }
 
     // Either no auto margins, or our margin box width is >= the container width, auto margins will just turn into 0.
     marginStart = marginStartWidth;
     marginEnd = marginEndWidth;
 }
 
+DISABLE_CFI_PERF
 void LayoutBox::updateLogicalHeight()
 {
     m_intrinsicContentLogicalHeight = contentLogicalHeight();
 
     LogicalExtentComputedValues computedValues;
     LayoutUnit height = style()->containsSize() ? borderAndPaddingLogicalHeight() : logicalHeight();
     computeLogicalHeight(height, logicalTop(), computedValues);
 
     setLogicalHeight(computedValues.m_extent);
     setLogicalTop(computedValues.m_position);
@@ skipping 1373 matching lines @@
             closestLayoutObject = layoutBox;
             minDist = dist;
         }
     }
 
     if (closestLayoutObject)
         return closestLayoutObject->positionForPoint(adjustedPoint - closestLayoutObject->locationOffset());
     return createPositionWithAffinity(firstPositionInOrBeforeNode(nonPseudoNode()));
 }
 
+DISABLE_CFI_PERF
 bool LayoutBox::shrinkToAvoidFloats() const
 {
     // Floating objects don't shrink.  Objects that don't avoid floats don't shrink.
     if (isInline() || !avoidsFloats() || isFloating())
         return false;
 
     // Only auto width objects can possibly shrink to avoid floats.
     return style()->width().isAuto();
 }
 
 static bool shouldBeConsideredAsReplaced(Node* node)
 {
     // Checkboxes and radioboxes are not isAtomicInlineLevel() nor do they have their own layoutObject in which to override avoidFloats().
     return node && node->isElementNode() && (toElement(node)->isFormControlElement() || isHTMLImageElement(toElement(node)));
 }
 
+DISABLE_CFI_PERF
 bool LayoutBox::avoidsFloats() const
 {
     return isAtomicInlineLevel() || shouldBeConsideredAsReplaced(node()) || hasOverflowClip() || isHR() || isLegend() || isWritingModeRoot() || isFlexItemIncludingDeprecated() || style()->containsPaint() || style()->containsLayout();
 }
 
 bool LayoutBox::hasNonCompositedScrollbars() const
 {
     if (PaintLayerScrollableArea* scrollableArea = this->getScrollableArea()) {
         if (scrollableArea->hasHorizontalScrollbar() && !scrollableArea->layerForHorizontalScrollbar())
             return true;
@@ skipping 73 matching lines @@
         int outlineOutset = style()->outlineOutsetExtent();
         top = std::max(top, -rect.y() + outlineOutset);
         right = std::max(right, rect.maxX() - size().width() + outlineOutset);
         bottom = std::max(bottom, rect.maxY() - size().height() + outlineOutset);
         left = std::max(left, -rect.x() + outlineOutset);
     }
 
     return LayoutRectOutsets(top, right, bottom, left);
 }
 
+DISABLE_CFI_PERF
 void LayoutBox::addOverflowFromChild(LayoutBox* child, const LayoutSize& delta)
 {
     // Never allow flow threads to propagate overflow up to a parent.
     if (child->isLayoutFlowThread())
         return;
 
     // Only propagate layout overflow from the child if the child isn't clipping its overflow.  If it is, then
     // its overflow is internal to it, and we don't care about it.  layoutOverflowRectForPropagation takes care of this
     // and just propagates the border box rect instead.
     LayoutRect childLayoutOverflowRect = child->layoutOverflowRectForPropagation(styleRef());
@@ skipping 13 matching lines @@
 bool LayoutBox::hasTopOverflow() const
 {
     return !style()->isLeftToRightDirection() && !isHorizontalWritingMode();
 }
 
 bool LayoutBox::hasLeftOverflow() const
 {
     return !style()->isLeftToRightDirection() && isHorizontalWritingMode();
 }
 
+DISABLE_CFI_PERF
 void LayoutBox::addLayoutOverflow(const LayoutRect& rect)
 {
     if (rect.isEmpty())
         return;
 
     LayoutRect clientBox = noOverflowRect();
     if (clientBox.contains(rect))
         return;
 
     // For overflow clip objects, we don't want to propagate overflow into unreachable areas.
@@ skipping 67 matching lines @@
 
     m_overflow->setLayoutOverflow(noOverflowRect());
 }
 
 bool LayoutBox::percentageLogicalHeightIsResolvable() const
 {
     Length fakeLength(100, Percent);
     return computePercentageLogicalHeight(fakeLength) != -1;
 }
 
+DISABLE_CFI_PERF
 bool LayoutBox::hasUnsplittableScrollingOverflow() const
 {
     // We will paginate as long as we don't scroll overflow in the pagination direction.
     bool isHorizontal = isHorizontalWritingMode();
     if ((isHorizontal && !scrollsOverflowY()) || (!isHorizontal && !scrollsOverflowX()))
         return false;
 
     // We do have overflow. We'll still be willing to paginate as long as the block
     // has auto logical height, auto or undefined max-logical-height and a zero or auto min-logical-height.
     // Note this is just a heuristic, and it's still possible to have overflow under these
@@ skipping 20 matching lines @@
     return AllowAnyBreaks;
 }
 
 LayoutUnit LayoutBox::lineHeight(bool /*firstLine*/, LineDirectionMode direction, LinePositionMode /*linePositionMode*/) const
 {
     if (isAtomicInlineLevel())
         return direction == HorizontalLine ? marginHeight() + size().height() : marginWidth() + size().width();
     return LayoutUnit();
 }
 
+DISABLE_CFI_PERF
 int LayoutBox::baselinePosition(FontBaseline baselineType, bool /*firstLine*/, LineDirectionMode direction, LinePositionMode linePositionMode) const
 {
     ASSERT(linePositionMode == PositionOnContainingLine);
     if (isAtomicInlineLevel()) {
         int result = direction == HorizontalLine ? roundToInt(marginHeight() + size().height()) : roundToInt(marginWidth() + size().width());
         if (baselineType == AlphabeticBaseline)
             return result;
         return result - result / 2;
     }
     return 0;
@@ skipping 13 matching lines @@
 }
 
 LayoutRect LayoutBox::logicalVisualOverflowRectForPropagation(const ComputedStyle& parentStyle) const
 {
     LayoutRect rect = visualOverflowRectForPropagation(parentStyle);
     if (!parentStyle.isHorizontalWritingMode())
         return rect.transposedRect();
     return rect;
 }
 
+DISABLE_CFI_PERF
 LayoutRect LayoutBox::visualOverflowRectForPropagation(const ComputedStyle& parentStyle) const
 {
     // If the writing modes of the child and parent match, then we don't have to
     // do anything fancy. Just return the result.
     LayoutRect rect = visualOverflowRect();
     if (parentStyle.getWritingMode() == style()->getWritingMode())
         return rect;
 
     // We are putting ourselves into our parent's coordinate space.  If there is a flipped block mismatch
     // in a particular axis, then we have to flip the rect along that axis.
     if (style()->getWritingMode() == RightToLeftWritingMode || parentStyle.getWritingMode() == RightToLeftWritingMode)
         rect.setX(size().width() - rect.maxX());
 
     return rect;
 }
 
+DISABLE_CFI_PERF
 LayoutRect LayoutBox::logicalLayoutOverflowRectForPropagation(const ComputedStyle& parentStyle) const
 {
     LayoutRect rect = layoutOverflowRectForPropagation(parentStyle);
     if (!parentStyle.isHorizontalWritingMode())
         return rect.transposedRect();
     return rect;
 }
 
+DISABLE_CFI_PERF
 LayoutRect LayoutBox::layoutOverflowRectForPropagation(const ComputedStyle& parentStyle) const
 {
     // Only propagate interior layout overflow if we don't clip it.
     LayoutRect rect = borderBoxRect();
     // We want to include the margin, but only when it adds height. Quirky margins don't contribute height
     // nor do the margins of self-collapsing blocks.
     if (!styleRef().hasMarginAfterQuirk() && !isSelfCollapsingBlock())
         rect.expand(isHorizontalWritingMode() ? LayoutSize(LayoutUnit(), marginAfter()) : LayoutSize(marginAfter(), LayoutUnit()));
 
     if (!hasOverflowClip())
@@ skipping 22 matching lines @@
         return rect;
 
     // We are putting ourselves into our parent's coordinate space.  If there is a flipped block mismatch
     // in a particular axis, then we have to flip the rect along that axis.
     if (style()->getWritingMode() == RightToLeftWritingMode || parentStyle.getWritingMode() == RightToLeftWritingMode)
         rect.setX(size().width() - rect.maxX());
 
     return rect;
 }
 
+DISABLE_CFI_PERF
 LayoutRect LayoutBox::noOverflowRect() const
 {
     // Because of the special coordinate system used for overflow rectangles and many other
     // rectangles (not quite logical, not quite physical), we need to flip the block progression
     // coordinate in vertical-rl writing mode. In other words, the rectangle returned is physical,
     // except for the block direction progression coordinate (x in vertical writing mode), which is
     // always "logical top". Apart from the flipping, this method does the same thing as
     // clientBoxRect().
 
     const int scrollBarWidth = verticalScrollbarWidth();
@@ skipping 452 matching lines @@
         m_rareData->m_snapAreas->remove(&snapArea);
     }
 }
 
 SnapAreaSet* LayoutBox::snapAreas() const
 {
     return m_rareData ? m_rareData->m_snapAreas.get() : nullptr;
 }
 
 } // namespace blink