Don't adjust for scrolling of the ancestor, rather than un-adjusting for it later.

third_party/WebKit/Source/core/layout/PaintInvalidationState.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/layout/PaintInvalidationState.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 182 matching lines @@
 
     if (position == FixedPosition) {
         if (m_paintInvalidationContainer != m_currentObject.view() && m_paintInvalidationContainer->view() == m_currentObject.view()) {
             // TODO(crbug.com/598762): localToAncestorPoint() is incorrect for fixed-position when paintInvalidationContainer
             // is under the containing LayoutView.
             m_cachedOffsetsEnabled = false;
             return;
         }
         // Use slow path to get the offset of the fixed-position, and enable fast path for descendants.
         FloatPoint fixedOffset = m_currentObject.localToAncestorPoint(FloatPoint(), m_paintInvalidationContainer, TraverseDocumentBoundaries);
+        if (m_paintInvalidationContainer->isBox()) {
+            const LayoutBox* box = toLayoutBox(m_paintInvalidationContainer);
+            if (box->hasOverflowClip())
+                fixedOffset.move(box->scrolledContentOffset());
+        }
         m_paintOffset = LayoutSize(fixedOffset.x(), fixedOffset.y());
         // In the above way to get paint offset, we can't get accurate clip rect, so just assume no clip.
         // Clip on fixed-position is rare, in case that paintInvalidationContainer crosses frame boundary
         // and the LayoutView is clipped by something in owner document.
         if (m_clipped) {
             m_clipped = false;
 #ifdef CHECK_FAST_PATH_SLOW_PATH_EQUALITY
             m_canCheckFastPathSlowPathEquality = false;
 #endif
         }
@@ skipping 87 matching lines @@
     } else if (m_currentObject.isTableRow()) {
         // Child table cell's locationOffset() includes its row's locationOffset().
         m_paintOffset -= toLayoutBox(m_currentObject).locationOffset();
     }
 
     if (!m_currentObject.hasOverflowClip())
         return;
 
     const LayoutBox& box = toLayoutBox(m_currentObject);
 
-    // Do not clip scroll layer contents because the compositor expects the whole layer
-    // to be always invalidated in-time.
-    if (box == m_paintInvalidationContainer && box.scrollsOverflow())
+    // Do not clip or scroll for the paint invalidation container, if it scrolls overflow, because it will always use composited
+    // scrolling in this case.
+    if (box == m_paintInvalidationContainer && box.scrollsOverflow()) {
         ASSERT(!m_clipped); // The box establishes paint invalidation container, so no m_clipped inherited.
-    else
+    } else {
         addClipRectRelativeToPaintOffset(box.overflowClipRect(LayoutPoint()));
-
-    m_paintOffset -= box.scrolledContentOffset();
+        m_paintOffset -= box.scrolledContentOffset();
+    }
 
     // FIXME: <http://bugs.webkit.org/show_bug.cgi?id=13443> Apply control clip if present.
 }
 
 static FloatPoint slowLocalToAncestorPoint(const LayoutObject& object, const LayoutBoxModelObject& ancestor, const FloatPoint& point)
 {
     if (object.isLayoutView())
         return toLayoutView(object).localToAncestorPoint(point, &ancestor, TraverseDocumentBoundaries | InputIsInFrameCoordinates);
-    return object.localToAncestorPoint(point, &ancestor, TraverseDocumentBoundaries);
+    FloatPoint result = object.localToAncestorPoint(point, &ancestor, TraverseDocumentBoundaries);
+    // Paint invalidation does not include scroll of the ancestor.
+    if (ancestor.isBox()) {
+        const LayoutBox* box = toLayoutBox(&ancestor);
+        if (box->hasOverflowClip())
+            result.move(box->scrolledContentOffset());
+    }
+    return result;
 }
 
 LayoutPoint PaintInvalidationState::computePositionFromPaintInvalidationBacking() const
 {
     ASSERT(!m_didUpdateForChildren);
 
     FloatPoint point;
     if (m_paintInvalidationContainer != &m_currentObject) {
         if (m_cachedOffsetsEnabled) {
             if (m_currentObject.isSVG() && !m_currentObject.isSVGRoot())
@@ skipping 157 matching lines @@
     WTFLogAlways("Fast path paint invalidation rect differs from slow path: fast: %s vs slow: %s",
         fastPathRect.toString().ascii().data(), slowPathRect.toString().ascii().data());
     showLayoutTree(&m_currentObject);
 
     ASSERT_NOT_REACHED();
 }
 
 #endif // CHECK_FAST_PATH_SLOW_PATH_EQUALITY
 
 } // namespace blink