Changeset 201635 in webkit for trunk/Source/WebCore/rendering/RenderBox.cpp

Timestamp:

Jun 2, 2016, 10:27:53 PM (10 years ago)

Author:

Alan Bujtas

Message:

Repaint issue with vertical text in an out of flow container.
​https://bugs.webkit.org/show_bug.cgi?id=102665
<rdar://problem/26605298>

Reviewed by David Hyatt.

Since the renderer’s offset for positioned objects is always physical, we only
need to flip the repaint rect(always logical) for writing root, when we see the first positioned object.
All subsequent writing root changes for positioned objects are okay and they don't need flipping.

Source/WebCore:

Test: fast/repaint/vertical-text-repaint.html

• rendering/RenderBox.cpp:

(WebCore::RenderBox::computeRectForRepaint):

• rendering/RenderBox.h:

(WebCore::RenderBox::computeRectForRepaint):

• rendering/RenderInline.cpp:

(WebCore::RenderInline::computeRectForRepaint):

• rendering/RenderInline.h:

(WebCore::RenderInline::computeRectForRepaint):

• rendering/RenderObject.cpp:

(WebCore::RenderObject::computeRectForRepaint):

• rendering/RenderObject.h:

(WebCore::RenderObject::computeAbsoluteRepaintRect):
(WebCore::RenderObject::computeRectForRepaint):

• rendering/RenderTableCell.cpp:

(WebCore::RenderTableCell::computeRectForRepaint):

• rendering/RenderTableCell.h:
• rendering/RenderView.cpp:

(WebCore::RenderView::computeRectForRepaint):

• rendering/RenderView.h:
• rendering/svg/RenderSVGForeignObject.cpp:

(WebCore::RenderSVGForeignObject::computeRectForRepaint):

• rendering/svg/RenderSVGForeignObject.h:
• rendering/svg/RenderSVGRoot.cpp:

(WebCore::RenderSVGRoot::computeFloatRectForRepaint):

• rendering/svg/RenderSVGText.cpp:

(WebCore::RenderSVGText::computeRectForRepaint):

• rendering/svg/RenderSVGText.h:

LayoutTests:

• fast/repaint/vertical-text-repaint-expected.txt: Added.
• fast/repaint/vertical-text-repaint.html: Added.

File:

• trunk/Source/WebCore/rendering/RenderBox.cpp (modified) (6 diffs)

trunk/Source/WebCore/rendering/RenderBox.cpp

@@ -2207 +2207 @@
 }
 
-LayoutRect RenderBox::computeRectForRepaint(const LayoutRect& rect, const RenderLayerModelObject* repaintContainer, bool fixed) const
+LayoutRect RenderBox::computeRectForRepaint(const LayoutRect& rect, const RenderLayerModelObject* repaintContainer, RepaintContext context) const
 {
     // The rect we compute at each step is shifted by our x/y offset in the parent container's coordinate space.
@@ -2246 +2246 @@
     }
 
-    bool containerSkipped;
-    auto* renderer = container(repaintContainer, containerSkipped);
-    if (!renderer)
+    bool repaintContainerIsSkipped;
+    auto* container = this->container(repaintContainer, repaintContainerIsSkipped);
+    if (!container)
         return adjustedRect;
     
-    EPosition position = styleToUse.position();
-
     // This code isn't necessary for in-flow RenderFlowThreads.
     // Don't add the location of the region in the flow thread for absolute positioned
@@ -2260 +2258 @@
     // The same logic applies for elements flowed directly into the flow thread. Their topLeft member
     // will already contain the portion rect of the region.
-    if (renderer->isOutOfFlowRenderFlowThread() && position != AbsolutePosition && containingBlock() != flowThreadContainingBlock()) {
+    EPosition position = styleToUse.position();
+    if (container->isOutOfFlowRenderFlowThread() && position != AbsolutePosition && containingBlock() != flowThreadContainingBlock()) {
         RenderRegion* firstRegion = nullptr;
         RenderRegion* lastRegion = nullptr;
-        if (downcast<RenderFlowThread>(*renderer).getRegionRangeForBox(this, firstRegion, lastRegion))
+        if (downcast<RenderFlowThread>(*container).getRegionRangeForBox(this, firstRegion, lastRegion))
             adjustedRect.moveBy(firstRegion->flowThreadPortionRect().location());
     }
 
-    if (isWritingModeRoot() && !isOutOfFlowPositioned())
-        flipForWritingMode(adjustedRect);
+    if (isWritingModeRoot()) {
+        if (!isOutOfFlowPositioned() || !context.m_dirtyRectIsFlipped) {
+            flipForWritingMode(adjustedRect);
+            context.m_dirtyRectIsFlipped = true;
+        }
+    }
 
     LayoutSize locationOffset = this->locationOffset();
@@ -2283 +2286 @@
     // in the parent's coordinate space that encloses us.
     if (hasLayer() && layer()->transform()) {
-        fixed = position == FixedPosition;
+        context.m_hasPositionFixedDescendant = position == FixedPosition;
         adjustedRect = LayoutRect(encloseRectToDevicePixels(layer()->transform()->mapRect(adjustedRect), document().deviceScaleFactor()));
         topLeft = adjustedRect.location();
         topLeft.move(locationOffset);
     } else if (position == FixedPosition)
-        fixed = true;
-
-    if (position == AbsolutePosition && renderer->isInFlowPositioned() && is<RenderInline>(*renderer))
-        topLeft += downcast<RenderInline>(*renderer).offsetForInFlowPositionedInline(this);
+        context.m_hasPositionFixedDescendant = true;
+
+    if (position == AbsolutePosition && container->isInFlowPositioned() && is<RenderInline>(*container))
+        topLeft += downcast<RenderInline>(*container).offsetForInFlowPositionedInline(this);
     else if (styleToUse.hasInFlowPosition() && layer()) {
         // Apply the relative position offset when invalidating a rectangle.  The layer
@@ -2303 +2306 @@
     // its controlClipRect will be wrong. For overflow clip we use the values cached by the layer.
     adjustedRect.setLocation(topLeft);
-    if (renderer->hasOverflowClip()) {
-        RenderBox& containerBox = downcast<RenderBox>(*renderer);
+    if (container->hasOverflowClip()) {
+        RenderBox& containerBox = downcast<RenderBox>(*container);
         if (shouldApplyContainersClipAndOffset(repaintContainer, &containerBox)) {
             containerBox.applyCachedClipAndScrollOffsetForRepaint(adjustedRect);
@@ -2312 +2315 @@
     }
 
-    if (containerSkipped) {
-        // If the repaintContainer is below o, then we need to map the rect into repaintContainer's coordinates.
-        LayoutSize containerOffset = repaintContainer->offsetFromAncestorContainer(*renderer);
+    if (repaintContainerIsSkipped) {
+        // If the repaintContainer is below container, then we need to map the rect into repaintContainer's coordinates.
+        LayoutSize containerOffset = repaintContainer->offsetFromAncestorContainer(*container);
         adjustedRect.move(-containerOffset);
         return adjustedRect;
     }
-    return renderer->computeRectForRepaint(adjustedRect, repaintContainer, fixed);
+    return container->computeRectForRepaint(adjustedRect, repaintContainer, context);
 }