Add DISABLE_CFI_PERF attribute on the methods with CFI checks disabled.

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

 /*
  * Copyright (C) 2011 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 983 matching lines @@
 bool LayoutGrid::updateOverrideContainingBlockContentSizeForChild(LayoutBox& child, GridTrackSizingDirection direction, GridSizingData& sizingData) const
 {
     LayoutUnit overrideSize = gridAreaBreadthForChild(child, direction, sizingData);
     if (hasOverrideContainingBlockContentSizeForChild(child, direction) && overrideContainingBlockContentSizeForChild(child, direction) == overrideSize)
         return false;
 
     setOverrideContainingBlockContentSizeForChild(child, direction, overrideSize);
     return true;
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutGrid::minContentForChild(LayoutBox& child, GridTrackSizingDirection direction, GridSizingData& sizingData) const
 {
     GridTrackSizingDirection childInlineDirection = flowAwareDirectionForChild(child, ForColumns);
     if (direction == childInlineDirection) {
         // If |child| has a relative logical width, we shouldn't let it override its intrinsic width, which is
         // what we are interested in here. Thus we need to set the inline-axis override size to -1 (no possible resolution).
         if (shouldClearOverrideContainingBlockContentSizeForChild(child, ForColumns))
             setOverrideContainingBlockContentSizeForChild(child, childInlineDirection, LayoutUnit(-1));
 
         // FIXME: It's unclear if we should return the intrinsic width or the preferred width.
         // See http://lists.w3.org/Archives/Public/www-style/2013Jan/0245.html
         return child.minPreferredLogicalWidth() + marginIntrinsicLogicalWidthForChild(child);
     }
 
     // All orthogonal flow boxes were already laid out during an early layout phase performed in FrameView::performLayout.
     // It's true that grid track sizing was not completed at that time and it may afffect the final height of a
     // grid item, but since it's forbidden to perform a layout during intrinsic width computation, we have to use
     // that computed height for now.
     if (direction == ForColumns && sizingData.sizingOperation == IntrinsicSizeComputation) {
         DCHECK(isOrthogonalChild(child));
         return child.logicalHeight() + child.marginLogicalHeight();
     }
 
     SubtreeLayoutScope layouter(child);
     if (updateOverrideContainingBlockContentSizeForChild(child, childInlineDirection, sizingData))
         child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
     return logicalHeightForChild(child, sizingData);
 }
 
+DISABLE_CFI_PERF
 LayoutUnit LayoutGrid::maxContentForChild(LayoutBox& child, GridTrackSizingDirection direction, GridSizingData& sizingData) const
 {
     GridTrackSizingDirection childInlineDirection = flowAwareDirectionForChild(child, ForColumns);
     if (direction == childInlineDirection) {
         // If |child| has a relative logical width, we shouldn't let it override its intrinsic width, which is
         // what we are interested in here. Thus we need to set the inline-axis override size to -1 (no possible resolution).
         if (shouldClearOverrideContainingBlockContentSizeForChild(child, ForColumns))
             setOverrideContainingBlockContentSizeForChild(child, childInlineDirection, LayoutUnit(-1));
 
         // FIXME: It's unclear if we should return the intrinsic width or the preferred width.
@@ skipping 1242 matching lines @@
 
 // TODO(lajava): This logic is shared by LayoutFlexibleBox, so it should be moved to LayoutBox.
 bool LayoutGrid::hasAutoMarginsInRowAxis(const LayoutBox& child) const
 {
     if (isHorizontalWritingMode())
         return child.styleRef().marginLeft().isAuto() || child.styleRef().marginRight().isAuto();
     return child.styleRef().marginTop().isAuto() || child.styleRef().marginBottom().isAuto();
 }
 
 // TODO(lajava): This logic is shared by LayoutFlexibleBox, so it should be moved to LayoutBox.
+DISABLE_CFI_PERF
 void LayoutGrid::updateAutoMarginsInRowAxisIfNeeded(LayoutBox& child)
 {
     ASSERT(!child.isOutOfFlowPositioned());
 
     LayoutUnit availableAlignmentSpace = child.overrideContainingBlockContentLogicalWidth() - child.logicalWidth() - child.marginLogicalWidth();
     if (availableAlignmentSpace <= 0)
         return;
 
     Length marginStart = child.style()->marginStartUsing(style());
     Length marginEnd = child.style()->marginEndUsing(style());
     if (marginStart.isAuto() && marginEnd.isAuto()) {
         child.setMarginStart(availableAlignmentSpace / 2, style());
         child.setMarginEnd(availableAlignmentSpace / 2, style());
     } else if (marginStart.isAuto()) {
         child.setMarginStart(availableAlignmentSpace, style());
     } else if (marginEnd.isAuto()) {
         child.setMarginEnd(availableAlignmentSpace, style());
     }
 }
 
 // TODO(lajava): This logic is shared by LayoutFlexibleBox, so it should be moved to LayoutBox.
+DISABLE_CFI_PERF
 void LayoutGrid::updateAutoMarginsInColumnAxisIfNeeded(LayoutBox& child)
 {
     ASSERT(!child.isOutOfFlowPositioned());
 
     LayoutUnit availableAlignmentSpace = child.overrideContainingBlockContentLogicalHeight() - child.logicalHeight() - child.marginLogicalHeight();
     if (availableAlignmentSpace <= 0)
         return;
 
     Length marginBefore = child.style()->marginBeforeUsing(style());
     Length marginAfter = child.style()->marginAfterUsing(style());
@@ skipping 336 matching lines @@
     return isOrthogonalChild(child) ? childLocation.transposedPoint() : childLocation;
 }
 
 void LayoutGrid::paintChildren(const PaintInfo& paintInfo, const LayoutPoint& paintOffset) const
 {
     if (!m_gridItemArea.isEmpty())
         GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 } // namespace blink