Root layer scrolling: set correct size for document's main GraphicsLayer.

third_party/WebKit/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 "core/paint/ViewPainter.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutView.h"
@@ skipping 37 matching lines @@
     //    canvas. None of the stacking context effects (except transformation) on the root element
     //    affects the background.
     // 3. The main frame is also responsible for painting the user-agent-defined base background
     //    color. Conceptually it should be painted by the embedder but painting it here allows
     //    culling and pre-blending optimization when possible.
 
     GraphicsContext& context = paintInfo.context;
     if (LayoutObjectDrawingRecorder::useCachedDrawingIfPossible(context, m_layoutView, DisplayItem::BoxDecorationBackground, LayoutPoint()))
         return;
 
-    IntRect documentRect = m_layoutView.documentRect();
+    // The background fill rect is the size of the LayoutView's main GraphicsLayer.
+    IntRect backgroundRect = pixelSnappedIntRect(m_layoutView.layer()->boundingBoxForCompositing());
     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();
     Color rootBackgroundColor = m_layoutView.style()->visitedDependentColor(CSSPropertyBackgroundColor);
     const LayoutObject* rootObject = document.documentElement() ? document.documentElement()->layoutObject() : nullptr;
 
-    LayoutObjectDrawingRecorder recorder(context, m_layoutView, DisplayItem::BoxDecorationBackground, documentRect, LayoutPoint());
+    LayoutObjectDrawingRecorder recorder(context, m_layoutView, DisplayItem::BoxDecorationBackground, backgroundRect, LayoutPoint());
 
     // Special handling for print economy mode.
     bool forceBackgroundToWhite = BoxPainter::shouldForceWhiteBackgroundForPrintEconomy(m_layoutView.styleRef(), document);
     if (forceBackgroundToWhite) {
         // If for any reason the view background is not transparent, paint white instead, otherwise keep transparent as is.
         if (paintsBaseBackground || rootBackgroundColor.alpha() || m_layoutView.style()->backgroundLayers().image())
-            context.fillRect(documentRect, Color::white, SkXfermode::kSrc_Mode);
+            context.fillRect(backgroundRect, Color::white, SkXfermode::kSrc_Mode);
         return;
     }
 
     // Compute the enclosing rect of the view, in root element space.
     //
     // For background colors we can simply paint the document rect in the default space.
     // However for background image, the root element transform applies. The strategy is to apply
     // root element transform on the context and issue draw commands in the local space, therefore
     // we need to apply inverse transform on the document rect to get to the root element space.
     bool backgroundRenderable = true;
     TransformationMatrix transform;
-    IntRect paintRect = documentRect;
+    IntRect paintRect = backgroundRect;
     if (!rootObject || !rootObject->isBox()) {
         backgroundRenderable = false;
     } else if (rootObject->hasLayer()) {
         const PaintLayer& rootLayer = *toLayoutBoxModelObject(rootObject)->layer();
         LayoutPoint offset;
         rootLayer.convertToLayerCoords(nullptr, offset);
         transform.translate(offset.x(), offset.y());
         transform.multiply(rootLayer.renderableTransform(paintInfo.globalPaintFlags()));
 
         if (!transform.isInvertible()) {
             backgroundRenderable = false;
         } else {
             bool isClamped;
-            paintRect = transform.inverse().projectQuad(FloatQuad(documentRect), &isClamped).enclosingBoundingBox();
+            paintRect = transform.inverse().projectQuad(FloatQuad(backgroundRect), &isClamped).enclosingBoundingBox();
             backgroundRenderable = !isClamped;
         }
     }
 
     if (!backgroundRenderable) {
         if (baseBackgroundColor.alpha())
-            context.fillRect(documentRect, baseBackgroundColor, shouldClearCanvas ? SkXfermode::kSrc_Mode : SkXfermode::kSrcOver_Mode);
+            context.fillRect(backgroundRect, baseBackgroundColor, shouldClearCanvas ? SkXfermode::kSrc_Mode : SkXfermode::kSrcOver_Mode);
         else if (shouldClearCanvas)
-            context.fillRect(documentRect, Color(), SkXfermode::kClear_Mode);
+            context.fillRect(backgroundRect, Color(), SkXfermode::kClear_Mode);
         return;
     }
 
     BoxPainter::FillLayerOcclusionOutputList reversedPaintList;
     bool shouldDrawBackgroundInSeparateBuffer = BoxPainter(m_layoutView).calculateFillLayerOcclusionCulling(reversedPaintList, m_layoutView.style()->backgroundLayers());
     ASSERT(reversedPaintList.size());
 
     // If the root background color is opaque, isolation group can be skipped because the canvas
     // will be cleared by root background color.
     if (!rootBackgroundColor.hasAlpha())
         shouldDrawBackgroundInSeparateBuffer = false;
 
     // We are going to clear the canvas with transparent pixels, isolation group can be skipped.
     if (!baseBackgroundColor.alpha() && shouldClearCanvas)
         shouldDrawBackgroundInSeparateBuffer = false;
 
     if (shouldDrawBackgroundInSeparateBuffer) {
         if (baseBackgroundColor.alpha())
-            context.fillRect(documentRect, baseBackgroundColor, shouldClearCanvas ? SkXfermode::kSrc_Mode : SkXfermode::kSrcOver_Mode);
+            context.fillRect(backgroundRect, 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);
+        context.fillRect(backgroundRect, combinedBackgroundColor, (shouldDrawBackgroundInSeparateBuffer || shouldClearCanvas) ? SkXfermode::kSrc_Mode : SkXfermode::kSrcOver_Mode);
     else if (shouldClearCanvas && !shouldDrawBackgroundInSeparateBuffer)
-        context.fillRect(documentRect, Color(), SkXfermode::kClear_Mode);
+        context.fillRect(backgroundRect, Color(), SkXfermode::kClear_Mode);
 
     for (auto it = reversedPaintList.rbegin(); it != reversedPaintList.rend(); ++it) {
         ASSERT((*it)->clip() == BorderFillBox);
 
         bool shouldPaintInViewportSpace = (*it)->attachment() == FixedBackgroundAttachment;
         if (shouldPaintInViewportSpace) {
             BoxPainter::paintFillLayerExtended(m_layoutView, paintInfo, Color(), **it, LayoutRect(LayoutRect::infiniteIntRect()), BackgroundBleedNone);
         } else {
             context.save();
             // TODO(trchen): We should be able to handle 3D-transformed root
             // background with slimming paint by using transform display items.
             context.concatCTM(transform.toAffineTransform());
             BoxPainter::paintFillLayerExtended(m_layoutView, paintInfo, Color(), **it, LayoutRect(paintRect), BackgroundBleedNone);
             context.restore();
         }
     }
 
     if (shouldDrawBackgroundInSeparateBuffer)
         context.endLayer();
 }
 
 } // namespace blink