Improvement handling of background and outline paint phases

third_party/WebKit/Source/core/paint/BlockPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/BlockPainter.h"
 
 #include "core/editing/DragCaretController.h"
 #include "core/editing/FrameSelection.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutBlockFlow.h"
@@ skipping 24 matching lines @@
     LayoutPoint adjustedPaintOffset = paintOffset + m_layoutBlock.location();
     PaintInfo localPaintInfo(paintInfo);
     PaintPhase originalPhase = localPaintInfo.phase;
 
     // There are some cases where not all clipped visual overflow is accounted for.
     // FIXME: reduce the number of such cases.
     ContentsClipBehavior contentsClipBehavior = ForceContentsClip;
     if (m_layoutBlock.hasOverflowClip() && !m_layoutBlock.hasControlClip() && !(m_layoutBlock.shouldPaintSelectionGaps() && originalPhase == PaintPhaseForeground) && !m_layoutBlock.hasCaret())
         contentsClipBehavior = SkipContentsClipIfPossible;
 
-    if (localPaintInfo.phase == PaintPhaseOutline) {
-        localPaintInfo.phase = PaintPhaseDescendantOutlines;
-    } else if (localPaintInfo.phase == PaintPhaseBlockBackground) {
-        localPaintInfo.phase = PaintPhaseSelfBlockBackground;
+    if (originalPhase == PaintPhaseOutline) {
+        localPaintInfo.phase = PaintPhaseDescendantOutlinesOnly;
+    } else if (shouldPaintSelfBlockBackground(originalPhase)) {
+        localPaintInfo.phase = PaintPhaseSelfBlockBackgroundOnly;
         m_layoutBlock.paintObject(localPaintInfo, adjustedPaintOffset);
-        localPaintInfo.phase = PaintPhaseDescendantBlockBackgrounds;
+        if (shouldPaintDescendantBlockBackgrounds(originalPhase))
+            localPaintInfo.phase = PaintPhaseDescendantBlockBackgroundsOnly;
     }
 
-    {
+    if (originalPhase != PaintPhaseSelfBlockBackgroundOnly && originalPhase != PaintPhaseSelfOutlineOnly) {
         BoxClipper boxClipper(m_layoutBlock, localPaintInfo, adjustedPaintOffset, contentsClipBehavior);
         m_layoutBlock.paintObject(localPaintInfo, adjustedPaintOffset);
     }
 
-    if (originalPhase == PaintPhaseOutline) {
-        localPaintInfo.phase = PaintPhaseSelfOutline;
+    if (shouldPaintSelfOutline(originalPhase)) {
+        localPaintInfo.phase = PaintPhaseSelfOutlineOnly;
         m_layoutBlock.paintObject(localPaintInfo, adjustedPaintOffset);
-        localPaintInfo.phase = originalPhase;
-    } else if (originalPhase == PaintPhaseBlockBackground) {
-        localPaintInfo.phase = originalPhase;
     }
 
     // Our scrollbar widgets paint exactly when we tell them to, so that they work properly with
     // z-index. We paint after we painted the background/border, so that the scrollbars will
     // sit above the background/border.
+    localPaintInfo.phase = originalPhase;
     paintOverflowControlsIfNeeded(localPaintInfo, adjustedPaintOffset);
 }
 
 void BlockPainter::paintOverflowControlsIfNeeded(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
-    PaintPhase phase = paintInfo.phase;
-    if (m_layoutBlock.hasOverflowClip() && m_layoutBlock.style()->visibility() == VISIBLE && (phase == PaintPhaseSelfBlockBackground || phase == PaintPhaseBlockBackground) && paintInfo.shouldPaintWithinRoot(&m_layoutBlock) && !paintInfo.paintRootBackgroundOnly()) {
+    if (m_layoutBlock.hasOverflowClip()
+        && m_layoutBlock.style()->visibility() == VISIBLE
+        && shouldPaintSelfBlockBackground(paintInfo.phase)
+        && paintInfo.shouldPaintWithinRoot(&m_layoutBlock)
+        && !paintInfo.paintRootBackgroundOnly()) {
         Optional<ClipRecorder> clipRecorder;
         if (!m_layoutBlock.layer()->isSelfPaintingLayer()) {
             LayoutRect clipRect = m_layoutBlock.borderBoxRect();
             clipRect.moveBy(paintOffset);
             clipRecorder.emplace(paintInfo.context, m_layoutBlock, DisplayItem::ClipScrollbarsToBoxBounds, clipRect);
         }
         ScrollableAreaPainter(*m_layoutBlock.layer()->scrollableArea()).paintOverflowControls(paintInfo.context, roundedIntPoint(paintOffset), paintInfo.cullRect(), false /* paintingOverlayControls */);
     }
 }
 
@@ skipping 43 matching lines @@
             paintInfo.context.paintController().invalidatePaintOffset(m_layoutBlock);
         }
         // Set previousPaintOffset here in case that m_layoutBlock paints nothing and no
         // LayoutObjectDrawingRecorder updates its previousPaintOffset.
         // TODO(wangxianzhu): Integrate paint offset checking into new paint invalidation.
         m_layoutBlock.mutableForPainting().setPreviousPaintOffset(paintOffset);
     }
 
     const PaintPhase paintPhase = paintInfo.phase;
 
-    if ((paintPhase == PaintPhaseSelfBlockBackground || paintPhase == PaintPhaseBlockBackground)
-        && m_layoutBlock.style()->visibility() == VISIBLE
-        && m_layoutBlock.hasBoxDecorationBackground())
-        m_layoutBlock.paintBoxDecorationBackground(paintInfo, paintOffset);
+    if (shouldPaintSelfBlockBackground(paintPhase)) {
+        if (m_layoutBlock.style()->visibility() == VISIBLE && m_layoutBlock.hasBoxDecorationBackground())
+            m_layoutBlock.paintBoxDecorationBackground(paintInfo, paintOffset);
+        // We're done. We don't bother painting any children.
+        if (paintPhase == PaintPhaseSelfBlockBackgroundOnly)
+            return;
+    }
+
+    if (paintInfo.paintRootBackgroundOnly())
+        return;
 
     if (paintPhase == PaintPhaseMask && m_layoutBlock.style()->visibility() == VISIBLE) {
         m_layoutBlock.paintMask(paintInfo, paintOffset);
         return;
     }
 
     if (paintPhase == PaintPhaseClippingMask && m_layoutBlock.style()->visibility() == VISIBLE) {
         BoxPainter(m_layoutBlock).paintClippingMask(paintInfo, paintOffset);
         return;
     }
 
     // FIXME: When Skia supports annotation rect covering (https://code.google.com/p/skia/issues/detail?id=3872),
     // this rect may be covered by foreground and descendant drawings. Then we may need a dedicated paint phase.
     if (paintPhase == PaintPhaseForeground && paintInfo.isPrinting())
         ObjectPainter(m_layoutBlock).addPDFURLRectIfNeeded(paintInfo, paintOffset);
 
-    {
+    if (paintPhase != PaintPhaseSelfOutlineOnly) {
         Optional<ScrollRecorder> scrollRecorder;
         Optional<PaintInfo> scrolledPaintInfo;
         if (m_layoutBlock.hasOverflowClip()) {
             IntSize scrollOffset = m_layoutBlock.scrolledContentOffset();
             if (m_layoutBlock.layer()->scrollsOverflow() || !scrollOffset.isZero()) {
                 scrollRecorder.emplace(paintInfo.context, m_layoutBlock, paintPhase, scrollOffset);
                 scrolledPaintInfo.emplace(paintInfo);
                 AffineTransform transform;
                 transform.translate(-scrollOffset.width(), -scrollOffset.height());
                 scrolledPaintInfo->updateCullRect(transform);
             }
         }
 
-        // We're done. We don't bother painting any children.
-        if (paintPhase == PaintPhaseSelfBlockBackground || paintInfo.paintRootBackgroundOnly())
-            return;
-
         const PaintInfo& contentsPaintInfo = scrolledPaintInfo ? *scrolledPaintInfo : paintInfo;
 
-        if (paintPhase != PaintPhaseSelfOutline)
-            paintContents(contentsPaintInfo, paintOffset);
+        paintContents(contentsPaintInfo, paintOffset);
 
         if (paintPhase == PaintPhaseForeground && !paintInfo.isPrinting())
             m_layoutBlock.paintSelection(contentsPaintInfo, paintOffset); // Fill in gaps in selection on lines and between blocks.
 
         if (paintPhase == PaintPhaseFloat || paintPhase == PaintPhaseSelection || paintPhase == PaintPhaseTextClip)
             m_layoutBlock.paintFloats(contentsPaintInfo, paintOffset);
     }
 
-    if ((paintPhase == PaintPhaseOutline || paintPhase == PaintPhaseSelfOutline) && m_layoutBlock.style()->hasOutline() && m_layoutBlock.style()->visibility() == VISIBLE)
+    if (shouldPaintSelfOutline(paintPhase))
         ObjectPainter(m_layoutBlock).paintOutline(paintInfo, paintOffset);
 
     // If the caret's node's layout object's containing block is this block, and the paint action is PaintPhaseForeground,
     // then paint the caret.
     if (paintPhase == PaintPhaseForeground && m_layoutBlock.hasCaret() && !LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(paintInfo.context, m_layoutBlock, DisplayItem::Caret, paintOffset)) {
         LayoutRect bounds = m_layoutBlock.visualOverflowRect();
         bounds.moveBy(paintOffset);
         LayoutObjectDrawingRecorder recorder(paintInfo.context, m_layoutBlock, DisplayItem::Caret, bounds, paintOffset);
         paintCarets(paintInfo, paintOffset);
     }
@@ skipping 24 matching lines @@
 
 void BlockPainter::paintContents(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     // Avoid painting descendants of the root element when stylesheets haven't loaded. This eliminates FOUC.
     // It's ok not to draw, because later on, when all the stylesheets do load, styleResolverChanged() on the Document
     // will do a full paint invalidation.
     if (m_layoutBlock.document().didLayoutWithPendingStylesheets() && !m_layoutBlock.isLayoutView())
         return;
 
     if (m_layoutBlock.childrenInline()) {
-        if (paintInfo.phase == PaintPhaseDescendantOutlines)
+        if (shouldPaintDescendantOutlines(paintInfo.phase))
             ObjectPainter(m_layoutBlock).paintInlineChildrenOutlines(paintInfo, paintOffset);
         else
             LineBoxListPainter(m_layoutBlock.lineBoxes()).paint(m_layoutBlock, paintInfo, paintOffset);
     } else {
-        PaintPhase newPhase = (paintInfo.phase == PaintPhaseDescendantOutlines) ? PaintPhaseOutline : paintInfo.phase;
-        newPhase = (newPhase == PaintPhaseDescendantBlockBackgrounds) ? PaintPhaseBlockBackground : newPhase;
-
-        // We don't paint our own background, but we do let the kids paint their backgrounds.
-        PaintInfo paintInfoForChild(paintInfo);
-        paintInfoForChild.phase = newPhase;
-        paintInfoForChild.updatePaintingRootForChildren(&m_layoutBlock);
-        m_layoutBlock.paintChildren(paintInfoForChild, paintOffset);
+        PaintInfo paintInfoForDescendants = paintInfo.forDescendants();
+        paintInfoForDescendants.updatePaintingRootForChildren(&m_layoutBlock);
+        m_layoutBlock.paintChildren(paintInfoForDescendants, paintOffset);
     }
 }
 
 } // namespace blink