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

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 238 matching lines @@
             else
                 unmarkOrthogonalWritingModeRoot();
         }
 
         clearPercentHeightDescendants();
     }
 
     // If our zoom factor changes and we have a defined scrollLeft/Top, we need to adjust that value into the
     // new zoomed coordinate space.
     if (hasOverflowClip() && oldStyle && oldStyle->effectiveZoom() != newStyle.effectiveZoom()) {
-        PaintLayerScrollableArea* scrollableArea = this->scrollableArea();
+        PaintLayerScrollableArea* scrollableArea = this->getScrollableArea();
         ASSERT(scrollableArea);
         if (int left = scrollableArea->scrollXOffset()) {
             left = (left / oldStyle->effectiveZoom()) * newStyle.effectiveZoom();
             scrollableArea->scrollToXOffset(left);
         }
         if (int top = scrollableArea->scrollYOffset()) {
             top = (top / oldStyle->effectiveZoom()) * newStyle.effectiveZoom();
             scrollableArea->scrollToYOffset(top);
         }
     }
 
     // Our opaqueness might have changed without triggering layout.
     if (diff.needsPaintInvalidation()) {
         LayoutObject* parentToInvalidate = parent();
         for (unsigned i = 0; i < backgroundObscurationTestMaxDepth && parentToInvalidate; ++i) {
             parentToInvalidate->invalidateBackgroundObscurationStatus();
             parentToInvalidate = parentToInvalidate->parent();
         }
     }
 
     if (isDocumentElement() || isBody()) {
         document().view()->recalculateScrollbarOverlayStyle(document().view()->documentBackgroundColor());
         document().view()->recalculateCustomScrollbarStyle();
         if (LayoutView* layoutView = view()) {
-            if (PaintLayerScrollableArea* scrollableArea = layoutView->scrollableArea()) {
+            if (PaintLayerScrollableArea* scrollableArea = layoutView->getScrollableArea()) {
                 if (scrollableArea->horizontalScrollbar() && scrollableArea->horizontalScrollbar()->isCustomScrollbar())
                     scrollableArea->horizontalScrollbar()->styleChanged();
                 if (scrollableArea->verticalScrollbar() && scrollableArea->verticalScrollbar()->isCustomScrollbar())
                     scrollableArea->verticalScrollbar()->styleChanged();
             }
         }
     }
     updateShapeOutsideInfoAfterStyleChange(*style(), oldStyle);
     updateGridPositionAfterStyleChange(oldStyle);
 
@@ skipping 137 matching lines @@
 }
 
 int LayoutBox::pixelSnappedOffsetHeight() const
 {
     return snapSizeToPixel(offsetHeight(), location().y() + clientTop());
 }
 
 LayoutUnit LayoutBox::scrollWidth() const
 {
     if (hasOverflowClip())
-        return scrollableArea()->scrollWidth();
+        return getScrollableArea()->scrollWidth();
     // For objects with visible overflow, this matches IE.
     // FIXME: Need to work right with writing modes.
     if (style()->isLeftToRightDirection())
         return std::max(clientWidth(), layoutOverflowRect().maxX() - borderLeft());
     return clientWidth() - std::min(LayoutUnit(), layoutOverflowRect().x() - borderLeft());
 }
 
 LayoutUnit LayoutBox::scrollHeight() const
 {
     if (hasOverflowClip())
-        return scrollableArea()->scrollHeight();
+        return getScrollableArea()->scrollHeight();
     // For objects with visible overflow, this matches IE.
     // FIXME: Need to work right with writing modes.
     return std::max(clientHeight(), layoutOverflowRect().maxY() - borderTop());
 }
 
 LayoutUnit LayoutBox::scrollLeft() const
 {
-    return hasOverflowClip() ? LayoutUnit(scrollableArea()->scrollXOffset()) : LayoutUnit();
+    return hasOverflowClip() ? LayoutUnit(getScrollableArea()->scrollXOffset()) : LayoutUnit();
 }
 
 LayoutUnit LayoutBox::scrollTop() const
 {
-    return hasOverflowClip() ? LayoutUnit(scrollableArea()->scrollYOffset()) : LayoutUnit();
+    return hasOverflowClip() ? LayoutUnit(getScrollableArea()->scrollYOffset()) : LayoutUnit();
 }
 
 int LayoutBox::pixelSnappedScrollWidth() const
 {
     return snapSizeToPixel(scrollWidth(), location().x() + clientLeft());
 }
 
 int LayoutBox::pixelSnappedScrollHeight() const
 {
     if (hasOverflowClip())
-        return snapSizeToPixel(scrollableArea()->scrollHeight(), location().y() + clientTop());
+        return snapSizeToPixel(getScrollableArea()->scrollHeight(), location().y() + clientTop());
     // For objects with visible overflow, this matches IE.
     // FIXME: Need to work right with writing modes.
     return snapSizeToPixel(scrollHeight(), location().y() + clientTop());
 }
 
 void LayoutBox::setScrollLeft(LayoutUnit newLeft)
 {
     // This doesn't hit in any tests, but since the equivalent code in setScrollTop
     // does, presumably this code does as well.
     DisableCompositingQueryAsserts disabler;
 
     if (hasOverflowClip())
-        scrollableArea()->scrollToXOffset(newLeft, ScrollOffsetClamped, ScrollBehaviorAuto);
+        getScrollableArea()->scrollToXOffset(newLeft, ScrollOffsetClamped, ScrollBehaviorAuto);
 }
 
 void LayoutBox::setScrollTop(LayoutUnit newTop)
 {
     // Hits in compositing/overflow/do-not-assert-on-invisible-composited-layers.html
     DisableCompositingQueryAsserts disabler;
 
     if (hasOverflowClip())
-        scrollableArea()->scrollToYOffset(newTop, ScrollOffsetClamped, ScrollBehaviorAuto);
+        getScrollableArea()->scrollToYOffset(newTop, ScrollOffsetClamped, ScrollBehaviorAuto);
 }
 
 void LayoutBox::scrollToOffset(const DoubleSize& offset, ScrollBehavior scrollBehavior)
 {
     // This doesn't hit in any tests, but since the equivalent code in setScrollTop
     // does, presumably this code does as well.
     DisableCompositingQueryAsserts disabler;
 
     if (hasOverflowClip())
-        scrollableArea()->scrollToOffset(offset, ScrollOffsetClamped, scrollBehavior);
+        getScrollableArea()->scrollToOffset(offset, ScrollOffsetClamped, scrollBehavior);
 }
 
 // Returns true iff we are attempting an autoscroll inside an iframe with scrolling="no".
 static bool isDisallowedAutoscroll(HTMLFrameOwnerElement* ownerElement, FrameView* frameView)
 {
     if (ownerElement && isHTMLFrameElementBase(*ownerElement)) {
         HTMLFrameElementBase* frameElementBase = toHTMLFrameElementBase(ownerElement);
         if (Page* page = frameView->frame().page()) {
             return page->autoscrollController().autoscrollInProgress()
                 && frameElementBase->scrollingMode() == ScrollbarAlwaysOff;
@@ skipping 13 matching lines @@
 
     bool restrictedByLineClamp = false;
     if (parent()) {
         parentBox = parent()->enclosingBox();
         restrictedByLineClamp = !parent()->style()->lineClamp().isNone();
     }
 
     if (hasOverflowClip() && !restrictedByLineClamp) {
         // Don't scroll to reveal an overflow layer that is restricted by the -webkit-line-clamp property.
         // This will prevent us from revealing text hidden by the slider in Safari RSS.
-        newRect = scrollableArea()->scrollIntoView(rect, alignX, alignY, scrollType);
+        newRect = getScrollableArea()->scrollIntoView(rect, alignX, alignY, scrollType);
     } else if (!parentBox && canBeProgramaticallyScrolled()) {
         if (FrameView* frameView = this->frameView()) {
             HTMLFrameOwnerElement* ownerElement = document().ownerElement();
             if (!isDisallowedAutoscroll(ownerElement, frameView)) {
                 if (makeVisibleInVisualViewport) {
-                    frameView->scrollableArea()->scrollIntoView(rect, alignX, alignY, scrollType);
+                    frameView->getScrollableArea()->scrollIntoView(rect, alignX, alignY, scrollType);
                 } else {
                     frameView->layoutViewportScrollableArea()->scrollIntoView(rect, alignX, alignY, scrollType);
                 }
                 if (ownerElement && ownerElement->layoutObject()) {
                     if (frameView->safeToPropagateScrollToParent()) {
                         parentBox = ownerElement->layoutObject()->enclosingBox();
                         // FIXME: This doesn't correctly convert the rect to
                         // absolute coordinates in the parent.
                         newRect.setX(rect.x() - frameView->scrollX() + frameView->x());
                         newRect.setY(rect.y() - frameView->scrollY() + frameView->y());
@@ skipping 77 matching lines @@
 
     return logicalHeight;
 }
 
 void LayoutBox::setLocationAndUpdateOverflowControlsIfNeeded(const LayoutPoint& location)
 {
     if (hasOverflowClip()) {
         IntSize oldPixelSnappedBorderRectSize = pixelSnappedBorderBoxRect().size();
         setLocation(location);
         if (pixelSnappedBorderBoxRect().size() != oldPixelSnappedBorderRectSize)
-            scrollableArea()->updateAfterLayout();
+            getScrollableArea()->updateAfterLayout();
         return;
     }
 
     setLocation(location);
 }
 
 IntRect LayoutBox::absoluteContentBox() const
 {
     // This is wrong with transforms and flipped writing modes.
     IntRect rect = pixelSnappedIntRect(contentBoxRect());
@@ skipping 72 matching lines @@
         break;
     }
     return result;
 }
 
 int LayoutBox::verticalScrollbarWidth() const
 {
     if (!hasOverflowClip() || style()->overflowY() == OverflowOverlay)
         return 0;
 
-    return scrollableArea()->verticalScrollbarWidth();
+    return getScrollableArea()->verticalScrollbarWidth();
 }
 
 int LayoutBox::horizontalScrollbarHeight() const
 {
     if (!hasOverflowClip() || style()->overflowX() == OverflowOverlay)
         return 0;
 
-    return scrollableArea()->horizontalScrollbarHeight();
+    return getScrollableArea()->horizontalScrollbarHeight();
 }
 
 int LayoutBox::intrinsicScrollbarLogicalWidth() const
 {
     if (!hasOverflowClip())
         return 0;
 
-    ASSERT(scrollableArea());
+    ASSERT(getScrollableArea());
 
     if (isHorizontalWritingMode() && style()->overflowY() == OverflowScroll) {
         // Even with OverflowScroll, the scrollbar may not exist (crbug.com/415031).
-        return scrollableArea()->hasVerticalScrollbar() ? verticalScrollbarWidth() : 0;
+        return getScrollableArea()->hasVerticalScrollbar() ? verticalScrollbarWidth() : 0;
     }
 
     if (!isHorizontalWritingMode() && style()->overflowX() == OverflowScroll) {
         // Even with OverflowScroll, the scrollbar may not exist (crbug.com/415031).
-        return scrollableArea()->hasHorizontalScrollbar() ? horizontalScrollbarHeight() : 0;
+        return getScrollableArea()->hasHorizontalScrollbar() ? horizontalScrollbarHeight() : 0;
     }
 
     return 0;
 }
 
 ScrollResult LayoutBox::scroll(ScrollGranularity granularity, const FloatSize& delta)
 {
     // Presumably the same issue as in setScrollTop. See crbug.com/343132.
     DisableCompositingQueryAsserts disabler;
 
-    if (!scrollableArea())
+    if (!getScrollableArea())
         return ScrollResult();
 
-    return scrollableArea()->userScroll(granularity, delta);
+    return getScrollableArea()->userScroll(granularity, delta);
 }
 
 bool LayoutBox::canBeScrolledAndHasScrollableArea() const
 {
     return canBeProgramaticallyScrolled() && (pixelSnappedScrollHeight() != pixelSnappedClientHeight() || pixelSnappedScrollWidth() != pixelSnappedClientWidth());
 }
 
 bool LayoutBox::canBeProgramaticallyScrolled() const
 {
     Node* node = this->node();
@@ skipping 123 matching lines @@
 void LayoutBox::scrollByRecursively(const DoubleSize& delta, ScrollOffsetClamping clamp)
 {
     if (delta.isZero())
         return;
 
     bool restrictedByLineClamp = false;
     if (parent())
         restrictedByLineClamp = !parent()->style()->lineClamp().isNone();
 
     if (hasOverflowClip() && !restrictedByLineClamp) {
-        PaintLayerScrollableArea* scrollableArea = this->scrollableArea();
+        PaintLayerScrollableArea* scrollableArea = this->getScrollableArea();
         ASSERT(scrollableArea);
 
         DoubleSize newScrollOffset = scrollableArea->adjustedScrollOffset() + delta;
         scrollableArea->scrollToOffset(newScrollOffset, clamp);
 
         // If this layer can't do the scroll we ask the next layer up that can scroll to try
         DoubleSize remainingScrollOffset = newScrollOffset - scrollableArea->adjustedScrollOffset();
         if (!remainingScrollOffset.isZero() && parent()) {
             if (LayoutBox* scrollableBox = enclosingScrollableBox())
                 scrollableBox->scrollByRecursively(remainingScrollOffset, clamp);
@@ skipping 16 matching lines @@
 bool LayoutBox::needsPreferredWidthsRecalculation() const
 {
     return style()->paddingStart().hasPercent() || style()->paddingEnd().hasPercent();
 }
 
 IntSize LayoutBox::scrolledContentOffset() const
 {
     ASSERT(hasOverflowClip());
     ASSERT(hasLayer());
     // FIXME: Return DoubleSize here. crbug.com/414283.
-    return flooredIntSize(scrollableArea()->scrollOffset());
+    return flooredIntSize(getScrollableArea()->scrollOffset());
 }
 
 void LayoutBox::mapScrollingContentsRectToBoxSpace(LayoutRect& rect) const
 {
     ASSERT(hasLayer());
     ASSERT(hasOverflowClip());
 
     LayoutSize offset = LayoutSize(-scrolledContentOffset());
     if (UNLIKELY(hasFlippedBlocksWritingMode())) {
         if (isHorizontalWritingMode())
@@ skipping 478 matching lines @@
         screenArea = static_cast<uint32_t>(screenRect.width() * screenRect.height());
     return ResourcePriority(isVisible ? ResourcePriority::Visible : ResourcePriority::NotVisible, screenArea);
 }
 
 bool LayoutBox::invalidatePaintOfLayerRectsForImage(WrappedImagePtr image, const FillLayer& layers, bool drawingBackground)
 {
     if (drawingBackground && (isDocumentElement() || backgroundStolenForBeingBody()))
         return false;
     for (const FillLayer* curLayer = &layers; curLayer; curLayer = curLayer->next()) {
         if (curLayer->image() && image == curLayer->image()->data()) {
-            bool maybeAnimated = curLayer->image()->cachedImage() && curLayer->image()->cachedImage()->image() && curLayer->image()->cachedImage()->image()->maybeAnimated();
+            bool maybeAnimated = curLayer->image()->cachedImage() && curLayer->image()->cachedImage()->getImage() && curLayer->image()->cachedImage()->getImage()->maybeAnimated();
             if (maybeAnimated && drawingBackground)
                 setShouldDoFullPaintInvalidation(PaintInvalidationDelayedFull);
             else
                 setShouldDoFullPaintInvalidation();
 
             if (drawingBackground)
                 invalidateBackgroundObscurationStatus();
             return true;
         }
     }
     return false;
 }
 
 bool LayoutBox::intersectsVisibleViewport()
 {
     LayoutRect rect = visualOverflowRect();
     LayoutView* layoutView = view();
     while (layoutView->frame()->ownerLayoutObject())
         layoutView = layoutView->frame()->ownerLayoutObject()->view();
     mapToVisibleRectInAncestorSpace(layoutView, rect, nullptr);
-    return rect.intersects(LayoutRect(layoutView->frameView()->scrollableArea()->visibleContentRectDouble()));
+    return rect.intersects(LayoutRect(layoutView->frameView()->getScrollableArea()->visibleContentRectDouble()));
 }
 
 PaintInvalidationReason LayoutBox::invalidatePaintIfNeeded(PaintInvalidationState& paintInvalidationState, const LayoutBoxModelObject& paintInvalidationContainer)
 {
     if (isFloating())
         paintInvalidationState.enclosingSelfPaintingLayer(*this).setNeedsPaintPhaseFloat();
 
     if (hasBoxDecorationBackground()
         // We also paint overflow controls in background phase.
-        || (hasOverflowClip() && scrollableArea()->hasOverflowControls())) {
+        || (hasOverflowClip() && getScrollableArea()->hasOverflowControls())) {
         PaintLayer& layer = paintInvalidationState.enclosingSelfPaintingLayer(*this);
         if (layer.layoutObject() != this)
             layer.setNeedsPaintPhaseDescendantBlockBackgrounds();
     }
 
     PaintInvalidationReason fullInvalidationReason = fullPaintInvalidationReason();
     // If the current paint invalidation reason is PaintInvalidationDelayedFull, then this paint invalidation can delayed if the
     // LayoutBox in question is not on-screen. The logic to decide whether this is appropriate exists at the site of the original
     // paint invalidation that chose PaintInvalidationDelayedFull.
     if (fullInvalidationReason == PaintInvalidationDelayedFull) {
         if (!intersectsVisibleViewport())
             return PaintInvalidationDelayedFull;
 
         // Reset state back to regular full paint invalidation if the object is onscreen.
         setShouldDoFullPaintInvalidation(PaintInvalidationFull);
     }
 
     PaintInvalidationReason reason = LayoutBoxModelObject::invalidatePaintIfNeeded(paintInvalidationState, paintInvalidationContainer);
 
     if (!view()->doingFullPaintInvalidation() && !isFullPaintInvalidationReason(reason))
         invalidatePaintForOverflowIfNeeded();
 
-    if (PaintLayerScrollableArea* area = scrollableArea())
+    if (PaintLayerScrollableArea* area = getScrollableArea())
         area->invalidatePaintOfScrollControlsIfNeeded(paintInvalidationState, paintInvalidationContainer);
 
     // This is for the next invalidatePaintIfNeeded so must be at the end.
     savePreviousBoxSizesIfNeeded();
     return reason;
 }
 
 void LayoutBox::invalidatePaintOfSubtreesIfNeeded(PaintInvalidationState& childPaintInvalidationState)
 {
     LayoutBoxModelObject::invalidatePaintOfSubtreesIfNeeded(childPaintInvalidationState);
@@ skipping 12 matching lines @@
     clipRect.setLocation(location + clipRect.location() + LayoutSize(borderLeft(), borderTop()));
     clipRect.setSize(clipRect.size() - LayoutSize(borderLeft() + borderRight(), borderTop() + borderBottom()));
 
     if (hasOverflowClip())
         excludeScrollbars(clipRect, relevancy);
     return clipRect;
 }
 
 void LayoutBox::excludeScrollbars(LayoutRect& rect, OverlayScrollbarSizeRelevancy relevancy) const
 {
-    if (PaintLayerScrollableArea* scrollableArea = this->scrollableArea()) {
+    if (PaintLayerScrollableArea* scrollableArea = this->getScrollableArea()) {
         if (shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
             rect.move(scrollableArea->verticalScrollbarWidth(relevancy), 0);
         rect.contract(scrollableArea->verticalScrollbarWidth(relevancy), scrollableArea->horizontalScrollbarHeight(relevancy));
     }
 }
 
 LayoutRect LayoutBox::clipRect(const LayoutPoint& location) const
 {
     LayoutRect borderBoxRect = this->borderBoxRect();
     LayoutRect clipRect = LayoutRect(borderBoxRect.location() + location, borderBoxRect.size());
@@ skipping 2064 matching lines @@
     }
 
     // If height of box is smaller than font height, use the latter one,
     // otherwise the caret might become invisible.
     //
     // Also, if the box is not an atomic inline-level element, always use the font height.
     // This prevents the "big caret" bug described in:
     // <rdar://problem/3777804> Deleting all content in a document can result in giant tall-as-window insertion point
     //
     // FIXME: ignoring :first-line, missing good reason to take care of
-    LayoutUnit fontHeight = LayoutUnit(style()->fontMetrics().height());
+    LayoutUnit fontHeight = LayoutUnit(style()->getFontMetrics().height());
     if (fontHeight > rect.height() || (!isAtomicInlineLevel() && !isTable()))
         rect.setHeight(fontHeight);
 
     if (extraWidthToEndOfLine)
         *extraWidthToEndOfLine = location().x() + size().width() - rect.maxX();
 
     // Move to local coords
     rect.moveBy(-location());
 
     // FIXME: Border/padding should be added for all elements but this workaround
@@ skipping 110 matching lines @@
     return node && node->isElementNode() && (toElement(node)->isFormControlElement() || isHTMLImageElement(toElement(node)));
 }
 
 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->scrollableArea()) {
+    if (PaintLayerScrollableArea* scrollableArea = this->getScrollableArea()) {
         if (scrollableArea->hasHorizontalScrollbar() && !scrollableArea->layerForHorizontalScrollbar())
             return true;
         if (scrollableArea->hasVerticalScrollbar() && !scrollableArea->layerForVerticalScrollbar())
             return true;
     }
     return false;
 }
 
 PaintInvalidationReason LayoutBox::getPaintInvalidationReason(const LayoutBoxModelObject& paintInvalidationContainer,
     const LayoutRect& oldBounds, const LayoutPoint& oldLocation, const LayoutRect& newBounds, const LayoutPoint& newLocation) const
@@ skipping 60 matching lines @@
         return PaintInvalidationBorderBoxChange;
 
     if (style()->hasVisualOverflowingEffect() || style()->hasAppearance() || style()->hasFilter() || style()->resize() != RESIZE_NONE)
         return PaintInvalidationBorderBoxChange;
 
     if (style()->hasBorderRadius()) {
         // If a border-radius exists and width/height is smaller than radius width/height,
         // we need to fully invalidate to cover the changed radius.
         FloatRoundedRect oldRoundedRect = style()->getRoundedBorderFor(LayoutRect(LayoutPoint(0, 0), oldBorderBoxSize));
         FloatRoundedRect newRoundedRect = style()->getRoundedBorderFor(LayoutRect(LayoutPoint(0, 0), newBorderBoxSize));
-        if (oldRoundedRect.radii() != newRoundedRect.radii())
+        if (oldRoundedRect.getRadii() != newRoundedRect.getRadii())
             return PaintInvalidationBorderBoxChange;
     }
 
     if (oldBorderBoxSize.width() != newBorderBoxSize.width() && mustInvalidateBackgroundOrBorderPaintOnWidthChange())
         return PaintInvalidationBorderBoxChange;
     if (oldBorderBoxSize.height() != newBorderBoxSize.height() && mustInvalidateBackgroundOrBorderPaintOnHeightChange())
         return PaintInvalidationBorderBoxChange;
 
     return PaintInvalidationIncremental;
 }
@@ skipping 785 matching lines @@
 }
 
 ShapeOutsideInfo* LayoutBox::shapeOutsideInfo() const
 {
     return ShapeOutsideInfo::isEnabledFor(*this) ? ShapeOutsideInfo::info(*this) : nullptr;
 }
 
 void LayoutBox::clearPreviousPaintInvalidationRects()
 {
     LayoutBoxModelObject::clearPreviousPaintInvalidationRects();
-    if (PaintLayerScrollableArea* scrollableArea = this->scrollableArea())
+    if (PaintLayerScrollableArea* scrollableArea = this->getScrollableArea())
         scrollableArea->clearPreviousPaintInvalidationRects();
 }
 
 void LayoutBox::setPercentHeightContainer(LayoutBlock* container)
 {
     ASSERT(!container || !percentHeightContainer());
     if (!container && !m_rareData)
         return;
     ensureRareData().m_percentHeightContainer = container;
 }
@@ skipping 18 matching lines @@
 }
 
 void LayoutBox::IntrinsicSizingInfo::transpose()
 {
     size = size.transposedSize();
     aspectRatio = aspectRatio.transposedSize();
     std::swap(hasWidth, hasHeight);
 }
 
 } // namespace blink