Remove the parameter of LayoutBox::XXXOverflowRectForPropagation()

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
@@ skipping 5046 matching lines @@
 
 DISABLE_CFI_PERF
 void LayoutBox::AddOverflowFromChild(const 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
+  // care about it. LayoutOverflowRectForPropagation takes care of this and just
   // propagates the border box rect instead.
   LayoutRect child_layout_overflow_rect =
-      child.LayoutOverflowRectForPropagation(StyleRef());
+      child.LayoutOverflowRectForPropagation();
   child_layout_overflow_rect.Move(delta);
   AddLayoutOverflow(child_layout_overflow_rect);
 
   // Add in visual overflow from the child.  Even if the child clips its
   // overflow, it may still have visual overflow of its own set from box shadows
   // or reflections. It is unnecessary to propagate this overflow if we are
   // clipping our own overflow.
   if (child.HasSelfPaintingLayer())
     return;
   LayoutRect child_visual_overflow_rect =
-      child.VisualOverflowRectForPropagation(StyleRef());
+      child.VisualOverflowRectForPropagation();
   child_visual_overflow_rect.Move(delta);
   AddContentsVisualOverflow(child_visual_overflow_rect);
 }
 
 bool LayoutBox::HasTopOverflow() const {
   return !Style()->IsLeftToRightDirection() && !IsHorizontalWritingMode();
 }
 
 bool LayoutBox::HasLeftOverflow() const {
   return !Style()->IsLeftToRightDirection() && IsHorizontalWritingMode();
@@ skipping 177 matching lines @@
   while (curr) {
     PaintLayer* layer =
         curr->HasLayer() && curr->IsBox() ? ToLayoutBox(curr)->Layer() : 0;
     if (layer && layer->IsSelfPaintingLayer())
       return layer;
     curr = curr->Parent();
   }
   return nullptr;
 }
 
-LayoutRect LayoutBox::LogicalVisualOverflowRectForPropagation(
-    const ComputedStyle& parent_style) const {
-  LayoutRect rect = VisualOverflowRectForPropagation(parent_style);
-  if (!parent_style.IsHorizontalWritingMode())
+LayoutRect LayoutBox::LogicalVisualOverflowRectForPropagation() const {
+  LayoutRect rect = VisualOverflowRectForPropagation();
+  if (!Parent()->StyleRef().IsHorizontalWritingMode())
     return rect.TransposedRect();
   return rect;
 }
 
 DISABLE_CFI_PERF
-LayoutRect LayoutBox::VisualOverflowRectForPropagation(
-    const ComputedStyle& parent_style) 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 (parent_style.GetWritingMode() == Style()->GetWritingMode())
+LayoutRect LayoutBox::RectForOverflowPropagation(const LayoutRect& rect) const {
+  // If the child and parent are in the same blocks direction, then we don't
+  // have to do anything fancy. Just return the rect.
+  if (Parent()->StyleRef().IsFlippedBlocksWritingMode() ==
+      StyleRef().IsFlippedBlocksWritingMode())
     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 (IsFlippedBlocksWritingMode(Style()->GetWritingMode()) ||
-      IsFlippedBlocksWritingMode(parent_style.GetWritingMode()))
-    rect.SetX(Size().Width() - rect.MaxX());
-
-  return rect;
+  // Convert the rect into parent's blocks direction by flipping along the y
+  // axis.
+  LayoutRect result = rect;
+  result.SetX(Size().Width() - rect.MaxX());
+  return result;
 }
 
 DISABLE_CFI_PERF
-LayoutRect LayoutBox::LogicalLayoutOverflowRectForPropagation(
-    const ComputedStyle& parent_style) const {
-  LayoutRect rect = LayoutOverflowRectForPropagation(parent_style);
-  if (!parent_style.IsHorizontalWritingMode())
+LayoutRect LayoutBox::LogicalLayoutOverflowRectForPropagation() const {
+  LayoutRect rect = LayoutOverflowRectForPropagation();
+  if (!Parent()->StyleRef().IsHorizontalWritingMode())
     return rect.TransposedRect();
   return rect;
 }
 
 DISABLE_CFI_PERF
-LayoutRect LayoutBox::LayoutOverflowRectForPropagation(
-    const ComputedStyle& parent_style) const {
+LayoutRect LayoutBox::LayoutOverflowRectForPropagation() 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())
     rect.Unite(LayoutOverflowRect());
 
   bool has_transform = HasLayer() && Layer()->Transform();
   if (IsInFlowPositioned() || has_transform) {
     // If we are relatively positioned or if we have a transform, then we have
     // to convert this rectangle into physical coordinates, apply relative
     // positioning and transforms to it, and then convert it back.
     FlipForWritingMode(rect);
 
     if (has_transform)
       rect = Layer()->CurrentTransform().MapRect(rect);
 
     if (IsInFlowPositioned())
       rect.Move(OffsetForInFlowPosition());
 
     // Now we need to flip back.
     FlipForWritingMode(rect);
   }
 
-  // If the writing modes of the child and parent match, then we don't have to
-  // do anything fancy. Just return the result.
-  if (parent_style.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 (IsFlippedBlocksWritingMode(Style()->GetWritingMode()) ||
-      IsFlippedBlocksWritingMode(parent_style.GetWritingMode()))
-    rect.SetX(Size().Width() - rect.MaxX());
-
-  return rect;
+  return RectForOverflowPropagation(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
@@ skipping 534 matching lines @@
 void LayoutBox::MutableForPainting::
     SavePreviousContentBoxSizeAndLayoutOverflowRect() {
   auto& rare_data = GetLayoutBox().EnsureRareData();
   rare_data.has_previous_content_box_size_and_layout_overflow_rect_ = true;
   rare_data.previous_content_box_size_ = GetLayoutBox().ContentBoxRect().Size();
   rare_data.previous_layout_overflow_rect_ =
       GetLayoutBox().LayoutOverflowRect();
 }
 
 }  // namespace blink