Fix background-attachment:local with --root-layer-scrolls

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"
+#include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/paint/BlockPainter.h"
 #include "core/paint/BoxPainter.h"
 #include "core/paint/LayoutObjectDrawingRecorder.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/PaintLayer.h"
+#include "core/paint/ScrollRecorder.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.
   DCHECK(!m_layoutView.needsLayout());
   // LayoutViews should never be called to paint with an offset not on device
@@ skipping 21 matching lines @@
   //    element.
   // 2. CSS background-clip is ignored, the background layers always expand to
   //    cover the whole 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::kDocumentBackground))
-    return;
 
   // The background rect always includes at least the visible content size.
   IntRect backgroundRect(IntRect(m_layoutView.viewRect()));
 
-  if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled() ||
-      BoxPainter::
+  if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled())
+    backgroundRect.unite(m_layoutView.documentRect());
+
+  const DisplayItemClient* displayItemClient = &m_layoutView;
+
+  Optional<ScrollRecorder> scrollRecorder;
+  if (BoxPainter::
           isPaintingBackgroundOfPaintContainerIntoScrollingContentsLayer(
               &m_layoutView, paintInfo)) {
     // Layout overflow, combined with the visible content size.
     backgroundRect.unite(m_layoutView.documentRect());
+    displayItemClient =
+        static_cast<const DisplayItemClient*>(m_layoutView.layer()
+                                                  ->compositedLayerMapping()
+                                                  ->scrollingContentsLayer());
+
+    scrollRecorder.emplace(paintInfo.context, m_layoutView, paintInfo.phase,
+                           m_layoutView.scrolledContentOffset());
   }
 
+  if (DrawingRecorder::useCachedDrawingIfPossible(
+          context, *displayItemClient, DisplayItem::kDocumentBackground))
+    return;
+
   const Document& document = m_layoutView.document();
   const FrameView& frameView = *m_layoutView.frameView();
   bool isMainFrame = document.isInMainFrame();
   bool paintsBaseBackground = isMainFrame && !frameView.isTransparent();
   bool shouldClearCanvas =
       paintsBaseBackground &&
       (document.settings() &&
        document.settings()->getShouldClearDocumentBackground());
   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::kDocumentBackground, backgroundRect);
+  DrawingRecorder recorder(context, *displayItemClient,
+                           DisplayItem::kDocumentBackground, backgroundRect);
 
   // 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())
@@ skipping 109 matching lines @@
                                  LayoutRect(paintRect), BackgroundBleedNone);
       context.restore();
     }
   }
 
   if (shouldDrawBackgroundInSeparateBuffer)
     context.endLayer();
 }
 
 }  // namespace blink