Add DISABLE_CFI_PERF attribute on the methods with CFI checks disabled.

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

 /*
  * Copyright (C) 2011 Google Inc. 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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 406 matching lines @@
 
     alignChildren(lineContexts, childToExclude);
 
     if (style()->flexWrap() == FlexWrapReverse)
         flipForWrapReverse(lineContexts, crossAxisStartEdge);
 
     // direction:rtl + flex-direction:column means the cross-axis direction is flipped.
     flipForRightToLeftColumn();
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::clientLogicalBottomAfterRepositioning()
 {
     LayoutUnit maxChildLogicalBottom;
     for (LayoutBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
         if (child->isOutOfFlowPositioned())
             continue;
         LayoutUnit childLogicalBottom = logicalTopForChild(*child) + logicalHeightForChild(*child) + marginAfterForChild(*child);
         maxChildLogicalBottom = std::max(maxChildLogicalBottom, childLogicalBottom);
     }
     return std::max(clientLogicalBottom(), maxChildLogicalBottom + paddingAfter());
@@ skipping 53 matching lines @@
     DCHECK(!hasOrthogonalFlow(child));
     if (needToStretchChildLogicalHeight(child)) {
         LayoutUnit childIntrinsicContentLogicalHeight;
         if (!child.styleRef().containsSize())
             childIntrinsicContentLogicalHeight = child.intrinsicContentLogicalHeight();
         return constrainedChildIntrinsicContentLogicalHeight(child, childIntrinsicContentLogicalHeight);
     }
     return child.logicalHeight();
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::childIntrinsicLogicalWidth(const LayoutBox& child) const
 {
     // This should only be called if the logical width is the cross size
     DCHECK(hasOrthogonalFlow(child));
     // If our height is auto, make sure that our returned height is unaffected by earlier layouts by
     // returning the max preferred logical width
     if (!crossAxisLengthIsDefinite(child, child.styleRef().logicalWidth()))
         return child.maxPreferredLogicalWidth();
 
     return child.logicalWidth();
@@ skipping 115 matching lines @@
         return LayoutUnit(borderBottom());
     case TransformedWritingMode::LeftToRightWritingMode:
         return LayoutUnit(borderLeft());
     case TransformedWritingMode::RightToLeftWritingMode:
         return LayoutUnit(borderRight());
     }
     NOTREACHED();
     return LayoutUnit(borderTop());
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::flowAwareBorderAfter() const
 {
     switch (getTransformedWritingMode()) {
     case TransformedWritingMode::TopToBottomWritingMode:
         return LayoutUnit(borderBottom());
     case TransformedWritingMode::BottomToTopWritingMode:
         return LayoutUnit(borderTop());
     case TransformedWritingMode::LeftToRightWritingMode:
         return LayoutUnit(borderRight());
     case TransformedWritingMode::RightToLeftWritingMode:
@@ skipping 26 matching lines @@
         return paddingBottom();
     case TransformedWritingMode::LeftToRightWritingMode:
         return paddingLeft();
     case TransformedWritingMode::RightToLeftWritingMode:
         return paddingRight();
     }
     NOTREACHED();
     return paddingTop();
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::flowAwarePaddingAfter() const
 {
     switch (getTransformedWritingMode()) {
     case TransformedWritingMode::TopToBottomWritingMode:
         return paddingBottom();
     case TransformedWritingMode::BottomToTopWritingMode:
         return paddingTop();
     case TransformedWritingMode::LeftToRightWritingMode:
         return paddingRight();
     case TransformedWritingMode::RightToLeftWritingMode:
         return paddingLeft();
     }
     NOTREACHED();
     return paddingTop();
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::flowAwareMarginStartForChild(const LayoutBox& child) const
 {
     if (isHorizontalFlow())
         return isLeftToRightFlow() ? child.marginLeft() : child.marginRight();
     return isLeftToRightFlow() ? child.marginTop() : child.marginBottom();
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::flowAwareMarginEndForChild(const LayoutBox& child) const
 {
     if (isHorizontalFlow())
         return isLeftToRightFlow() ? child.marginRight() : child.marginLeft();
     return isLeftToRightFlow() ? child.marginBottom() : child.marginTop();
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::flowAwareMarginBeforeForChild(const LayoutBox& child) const
 {
     switch (getTransformedWritingMode()) {
     case TransformedWritingMode::TopToBottomWritingMode:
         return child.marginTop();
     case TransformedWritingMode::BottomToTopWritingMode:
         return child.marginBottom();
     case TransformedWritingMode::LeftToRightWritingMode:
         return child.marginLeft();
     case TransformedWritingMode::RightToLeftWritingMode:
@@ skipping 125 matching lines @@
     }
     m_intrinsicSizeAlongMainAxis.set(&child, mainSize);
     m_relaidOutChildren.add(&child);
 }
 
 void LayoutFlexibleBox::clearCachedMainSizeForChild(const LayoutBox& child)
 {
     m_intrinsicSizeAlongMainAxis.remove(&child);
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::computeInnerFlexBaseSizeForChild(LayoutBox& child, LayoutUnit mainAxisBorderAndPadding, ChildLayoutType childLayoutType)
 {
     child.clearOverrideSize();
 
     if (child.isImage() || child.isVideo() || child.isCanvas())
         UseCounter::count(document(), UseCounter::AspectRatioFlexItem);
 
     Length flexBasis = flexBasisForChild(child);
     if (mainAxisLengthIsDefinite(child, flexBasis))
         return std::max(LayoutUnit(), computeMainAxisExtentForChild(child, MainOrPreferredSize, flexBasis));
@@ skipping 198 matching lines @@
 
         if (isHorizontal)
             child.setMarginBottom(availableAlignmentSpace);
         else
             child.setMarginRight(availableAlignmentSpace);
         return true;
     }
     return false;
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::marginBoxAscentForChild(const LayoutBox& child)
 {
     LayoutUnit ascent(child.firstLineBoxBaseline());
     if (ascent == -1)
         ascent = crossAxisExtentForChild(child);
     return ascent + flowAwareMarginBeforeForChild(child);
 }
 
 LayoutUnit LayoutFlexibleBox::computeChildMarginValue(Length margin)
 {
@@ skipping 18 matching lines @@
         if (isHorizontalFlow()) {
             child->setMarginLeft(computeChildMarginValue(child->style()->marginLeft()));
             child->setMarginRight(computeChildMarginValue(child->style()->marginRight()));
         } else {
             child->setMarginTop(computeChildMarginValue(child->style()->marginTop()));
             child->setMarginBottom(computeChildMarginValue(child->style()->marginBottom()));
         }
     }
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutFlexibleBox::adjustChildSizeForMinAndMax(const LayoutBox& child, LayoutUnit childSize)
 {
     Length max = isHorizontalFlow() ? child.style()->maxWidth() : child.style()->maxHeight();
     LayoutUnit maxExtent(-1);
     if (max.isSpecifiedOrIntrinsic()) {
         maxExtent = computeMainAxisExtentForChild(child, MaxSize, max);
         DCHECK_GE(maxExtent, LayoutUnit(-1));
         if (maxExtent != -1 && childSize > maxExtent)
             childSize = maxExtent;
     }
@@ skipping 96 matching lines @@
     }
 
     if (crossAxisLengthIsDefinite(child, crossMin)) {
         LayoutUnit minValue = computeMainSizeFromAspectRatioUsing(child, crossMin);
         childSize = std::max(minValue, childSize);
     }
 
     return childSize;
 }
 
+DISABLE_CFI_PERF
 LayoutFlexibleBox::FlexItem LayoutFlexibleBox::constructFlexItem(LayoutBox& child, ChildLayoutType layoutType)
 {
     LayoutUnit borderAndPadding = isHorizontalFlow() ? child.borderAndPaddingWidth() : child.borderAndPaddingHeight();
     LayoutUnit childInnerFlexBaseSize = computeInnerFlexBaseSizeForChild(child, borderAndPadding, layoutType);
     LayoutUnit childMinMaxAppliedMainAxisExtent = adjustChildSizeForMinAndMax(child, childInnerFlexBaseSize);
     LayoutUnit margin = isHorizontalFlow() ? child.marginWidth() : child.marginHeight();
     return FlexItem(&child, childInnerFlexBaseSize, childMinMaxAppliedMainAxisExtent, borderAndPadding, margin);
 }
 
 bool LayoutFlexibleBox::computeNextFlexLine(OrderedFlexItemList& orderedChildren, LayoutUnit& sumFlexBaseSize, double& totalFlexGrow, double& totalFlexShrink, double& totalWeightedFlexShrink, LayoutUnit& sumHypotheticalMainSize, bool relayoutChildren, LayoutObject* childToExclude)
@@ skipping 374 matching lines @@
     return child.styleRef().overflowY();
 }
 
 EOverflow LayoutFlexibleBox::crossAxisOverflowForChild(const LayoutBox& child) const
 {
     if (isHorizontalFlow())
         return child.styleRef().overflowY();
     return child.styleRef().overflowX();
 }
 
+DISABLE_CFI_PERF
 void LayoutFlexibleBox::layoutAndPlaceChildren(LayoutUnit& crossAxisOffset, const OrderedFlexItemList& children, LayoutUnit availableFreeSpace, bool relayoutChildren, SubtreeLayoutScope& layoutScope, Vector<LineContext>& lineContexts)
 {
     ContentPosition position = styleRef().resolvedJustifyContentPosition(contentAlignmentNormalBehavior());
     ContentDistributionType distribution = styleRef().resolvedJustifyContentDistribution(contentAlignmentNormalBehavior());
 
     size_t numberOfChildrenForJustifyContent = numberOfInFlowPositionedChildren(children);
     LayoutUnit autoMarginOffset = autoMarginOffsetInMainAxis(children, availableFreeSpace);
     LayoutUnit mainAxisOffset = flowAwareBorderStart() + flowAwarePaddingStart();
     mainAxisOffset += initialJustifyContentOffset(availableFreeSpace, position, distribution, numberOfChildrenForJustifyContent);
     if (style()->flexDirection() == FlowRowReverse && shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
@@ skipping 309 matching lines @@
             DCHECK(child);
             LayoutUnit lineCrossAxisExtent = lineContexts[lineNumber].crossAxisExtent;
             LayoutUnit originalOffset = lineContexts[lineNumber].crossAxisOffset - crossAxisStartEdge;
             LayoutUnit newOffset = contentExtent - originalOffset - lineCrossAxisExtent;
             adjustAlignmentForChild(*child, newOffset - originalOffset);
         }
     }
 }
 
 } // namespace blink