Refactor root element background painting

Source/core/paint/ViewPainter.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 "config.h"
 #include "core/paint/ViewPainter.h"
 
 #include "core/frame/FrameView.h"
+#include "core/frame/Settings.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/BlockPainter.h"
+#include "core/paint/BoxPainter.h"
+#include "core/paint/DeprecatedPaintLayer.h"
 #include "core/paint/LayoutObjectDrawingRecorder.h"
 #include "core/paint/PaintInfo.h"
 #include "platform/RuntimeEnabledFeatures.h"
 
 namespace blink {
 
 void ViewPainter::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     // If we ever require layout but receive a paint anyway, something has gone horribly wrong.
     ASSERT(!m_layoutView.needsLayout());
     // LayoutViews should never be called to paint with an offset not on device pixels.
     ASSERT(LayoutPoint(IntPoint(paintOffset.x(), paintOffset.y())) == paintOffset);
 
     // This avoids painting garbage between columns if there is a column gap.
     // This is legacy WebKit behavior and doesn't work with slimmingpaint. We can remove it once region-based columns are launched.
     if (!RuntimeEnabledFeatures::regionBasedColumnsEnabled() && m_layoutView.frameView() && m_layoutView.style()->isOverflowPaged()) {
         ASSERT(!RuntimeEnabledFeatures::slimmingPaintEnabled());
         LayoutRect paintRect(paintInfo.rect);
         paintInfo.context->fillRect(paintRect, m_layoutView.frameView()->baseBackgroundColor());
     }
 
     m_layoutView.paintObject(paintInfo, paintOffset);
     BlockPainter(m_layoutView).paintOverflowControlsIfNeeded(paintInfo, paintOffset);
 }
 
-static inline bool layoutObjectObscuresBackground(LayoutBox* rootBox)
-{
-    ASSERT(rootBox);
-    const ComputedStyle& style = rootBox->styleRef();
-    if (style.visibility() != VISIBLE
-        || style.opacity() != 1
-        || style.hasFilter()
-        || style.hasTransform())
-        return false;
-
-    if (rootBox->compositingState() == PaintsIntoOwnBacking)
-        return false;
-
-    const LayoutObject* rootLayoutObject = rootBox->layoutObjectForRootBackground();
-    if (rootLayoutObject->style()->backgroundClip() == TextFillBox)
-        return false;
-
-    return true;
-}
-
 void ViewPainter::paintBoxDecorationBackground(const PaintInfo& paintInfo)
 {
-    if (m_layoutView.document().ownerElement() || !m_layoutView.view())
-        return;
-
     if (paintInfo.skipRootBackground())
         return;
 
-    bool shouldPaintBackground = true;
-    Node* documentElement = m_layoutView.document().documentElement();
-    if (LayoutBox* rootBox = documentElement ? toLayoutBox(documentElement->layoutObject()) : 0)
-        shouldPaintBackground = !rootFillsViewportBackground(rootBox) || !layoutObjectObscuresBackground(rootBox);
+    GraphicsContext& context = *paintInfo.context;
+    IntRect documentRect = m_layoutView.unscaledDocumentRect();
+    const Document& document = m_layoutView.document();
+    const FrameView& frameView = *m_layoutView.frameView();
+    bool isMainFrame = !document.ownerElement();
+    bool paintsBaseBackground = isMainFrame && !frameView.isTransparent();
+    bool shouldClearCanvas = paintsBaseBackground && (document.settings() && document.settings()->shouldClearDocumentBackground());
+    Color baseBackgroundColor = paintsBaseBackground ? frameView.baseBackgroundColor() : Color();
+    const LayoutObject* rootObject = document.documentElement() ? document.documentElement()->layoutObject() : nullptr;
 
-    // If painting will entirely fill the view, no need to fill the background.
-    if (!shouldPaintBackground)
+    LayoutObjectDrawingRecorder recorder(context, m_layoutView, DisplayItem::BoxDecorationBackground, documentRect);
+    if (recorder.canUseCachedDrawing())
         return;
 
-    // This code typically only executes if the root element's visibility has been set to hidden,
-    // if there is a transform on the <html>, or if there is a page scale factor less than 1.
-    // Only fill with the base background color (typically white) if we're the root document,
-    // since iframes/frames with no background in the child document should show the parent's background.
-    if (!m_layoutView.frameView()->isTransparent()) {
-        LayoutRect paintRect(paintInfo.rect);
-        if (RuntimeEnabledFeatures::slimmingPaintEnabled())
-            paintRect = m_layoutView.viewRect();
+    bool backgroundRenderable = true;
+    TransformationMatrix transform;
+    IntRect paintRect = documentRect;
+    if (!rootObject || !rootObject->isBox()) {
+        backgroundRenderable = false;
+    } else if (rootObject->hasLayer()) {
+        const DeprecatedPaintLayer& rootLayer = *toLayoutBoxModelObject(rootObject)->layer();
+        LayoutPoint offset;
+        rootLayer.convertToLayerCoords(nullptr, offset);
+        transform.translate(offset.x(), offset.y());
+        transform.multiply(rootLayer.renderableTransform(paintInfo.paintBehavior));

[Xianzhu, 2015/06/03 04:40:34]

Do we need to invalidate / have we invalidated the layoutView when rootLayer's
offset or transform change?

[trchen, 2015/06/03 23:15:24]

Yes we do. Tried with the inspector we are already doing it correctly.

[Xianzhu, 2015/06/03 23:24:19]

The paint invalidation rect shown by inspector doesn't ensure the invalidation
is correct for slimming paint because the invalidation might be for the
documentElement, not the layoutView. Do we have test coverage for the case?

 
-        LayoutObjectDrawingRecorder recorder(*paintInfo.context, m_layoutView, DisplayItem::BoxDecorationBackground, m_layoutView.viewRect());
-        if (!recorder.canUseCachedDrawing()) {
-            Color baseColor = m_layoutView.frameView()->baseBackgroundColor();
-            paintInfo.context->fillRect(paintRect, baseColor, baseColor.alpha() ?
-                SkXfermode::kSrc_Mode : SkXfermode::kClear_Mode);
+        if (!transform.isInvertible()) {
+            backgroundRenderable = false;
+        } else {
+            bool isClamped;
+            paintRect = transform.inverse().projectQuad(FloatQuad(documentRect), &isClamped).enclosingBoundingBox();
+            backgroundRenderable = !isClamped;
         }
     }
-}
 
-bool ViewPainter::rootFillsViewportBackground(LayoutBox* rootBox) const
-{
-    ASSERT(rootBox);
-    // CSS Boxes always fill the viewport background (see paintRootBoxFillLayers)
-    if (!rootBox->isSVG())
-        return true;
+    if (!backgroundRenderable) {
+        if (baseBackgroundColor.alpha())
+            context.fillRect(documentRect, baseBackgroundColor, shouldClearCanvas ? SkXfermode::kSrc_Mode : SkXfermode::kSrcOver_Mode);
+        else if (shouldClearCanvas)
+            context.fillRect(documentRect, Color(), SkXfermode::kClear_Mode);
+        return;
+    }
 
-    return rootBox->frameRect().contains(m_layoutView.frameRect());
+    Vector<const FillLayer*, 8> reversedPaintList;
+    bool shouldDrawBackgroundInSeparateBuffer = BoxPainter(m_layoutView).calculateFillLayerOcclusionCulling(reversedPaintList, m_layoutView.style()->backgroundLayers());
+    ASSERT(reversedPaintList.size());
+    Color rootBackgroundColor = m_layoutView.style()->visitedDependentColor(CSSPropertyBackgroundColor);
+    if (!rootBackgroundColor.hasAlpha())
+        shouldDrawBackgroundInSeparateBuffer = false;
+
+    if (!baseBackgroundColor.alpha() && shouldClearCanvas)
+        shouldDrawBackgroundInSeparateBuffer = false;
+
+    if (shouldDrawBackgroundInSeparateBuffer) {
+        if (baseBackgroundColor.alpha())
+            context.fillRect(documentRect, baseBackgroundColor, shouldClearCanvas ? SkXfermode::kSrc_Mode : SkXfermode::kSrcOver_Mode);
+        context.beginLayer();
+    }
+
+    Color combinedBackgroundColor = shouldDrawBackgroundInSeparateBuffer ? rootBackgroundColor : baseBackgroundColor.blend(rootBackgroundColor);
+    if (combinedBackgroundColor.alpha())
+        context.fillRect(documentRect, combinedBackgroundColor, (shouldDrawBackgroundInSeparateBuffer || shouldClearCanvas) ? SkXfermode::kSrc_Mode : SkXfermode::kSrcOver_Mode);
+    else if (shouldClearCanvas && !shouldDrawBackgroundInSeparateBuffer)
+        context.fillRect(documentRect, Color(), SkXfermode::kClear_Mode);
+
+    {
+        GraphicsContextStateSaver stateSaver(context);
+        // TODO(trchen): We should be able to handle 3D-transformed root
+        // background with slimming paint by using transform display items.
+        context.concatCTM(transform.toAffineTransform());
+        for (auto it = reversedPaintList.rbegin(); it != reversedPaintList.rend(); ++it) {
+            ASSERT((*it)->clip() == BorderFillBox);
+            BoxPainter::paintFillLayerExtended(m_layoutView, paintInfo, Color(), **it, LayoutRect(paintRect), BackgroundBleedNone);
+        }
+    }
+
+    if (shouldDrawBackgroundInSeparateBuffer)
+        context.endLayer();
 }
 
 } // namespace blink