Fix paint invalidation of paintInvalidationContainer itself

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/layout/LayoutInline.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/svg/LayoutSVGModelObject.h"
 #include "core/layout/svg/LayoutSVGRoot.h"
@@ skipping 55 matching lines @@
             if (fixed) {
                 FloatPoint fixedOffset = layoutObject.localToAncestorPoint(FloatPoint(), &m_paintInvalidationContainer, TraverseDocumentBoundaries);
                 m_paintOffset = LayoutSize(fixedOffset.x(), fixedOffset.y());
             } else {
                 LayoutSize offset = layoutObject.isBox() && !layoutObject.isTableRow() ? toLayoutBox(layoutObject).locationOffset() : LayoutSize();
                 m_paintOffset = next.m_paintOffset + offset;
             }
 
             if (layoutObject.isOutOfFlowPositioned() && !fixed) {
                 if (LayoutObject* container = layoutObject.container()) {
-                    if (container->style()->hasInFlowPosition() && container->isLayoutInline())
+                    if (container->isInFlowPositioned() && container->isLayoutInline())
                         m_paintOffset += toLayoutInline(container)->offsetForInFlowPositionedInline(toLayoutBox(layoutObject));
                 }
             }
 
-            if (layoutObject.style()->hasInFlowPosition() && layoutObject.hasLayer())
+            if (layoutObject.isInFlowPositioned() && layoutObject.hasLayer())
                 m_paintOffset += layoutObject.layer()->offsetForInFlowPosition();
         }
 
         m_clipped = !fixed && next.m_clipped;
         if (m_clipped)
             m_clipRect = next.m_clipRect;
     }
 
     if (m_cachedOffsetsEnabled && layoutObject.isSVGRoot()) {
         const LayoutSVGRoot& svgRoot = toLayoutSVGRoot(layoutObject);
@@ skipping 18 matching lines @@
     , m_paintInvalidationContainer(next.m_paintInvalidationContainer)
     , m_pendingDelayedPaintInvalidations(next.pendingDelayedPaintInvalidationTargets())
     , m_enclosingSelfPaintingLayer(next.enclosingSelfPaintingLayer(layoutObject))
 {
     ASSERT(layoutObject != m_paintInvalidationContainer);
 
     if (m_cachedOffsetsEnabled)
         m_svgTransform = AffineTransform(next.svgTransform() * layoutObject.localToParentTransform());
 }
 
+void PaintInvalidationState::mapObjectRectToAncestor(const LayoutObject& object, const LayoutBoxModelObject* ancestor, LayoutRect& rect) const
+{
+    ASSERT(canMapToAncestor(ancestor));
+
+    if (ancestor == &object) {
+        if (object.isBox() && object.styleRef().isFlippedBlocksWritingMode())
+            toLayoutBox(object).flipForWritingMode(rect);
+        return;
+    }
+
+    if (object.hasLayer()) {
+        if (const TransformationMatrix* transform = toLayoutBoxModelObject(object).layer()->transform())
+            rect = LayoutRect(transform->mapRect(pixelSnappedIntRect(rect)));
+
+        if (object.isInFlowPositioned())
+            rect.move(toLayoutBoxModelObject(object).layer()->offsetForInFlowPosition());
+    }
+
+    if (object.isBox())
+        rect.moveBy(toLayoutBox(object).location());
+
+    rect.move(m_paintOffset);
+
+    if (m_clipped)
+        rect.intersect(m_clipRect);
+}
+
 void PaintInvalidationState::addClipRectRelativeToPaintOffset(const LayoutSize& clipSize)
 {
     LayoutRect clipRect(toPoint(m_paintOffset), clipSize);
     if (m_clipped) {
         m_clipRect.intersect(clipRect);
     } else {
         m_clipRect = clipRect;
         m_clipped = true;
     }
 }
@@ skipping 17 matching lines @@
 
 PaintLayer& PaintInvalidationState::enclosingSelfPaintingLayer(const LayoutObject& layoutObject) const
 {
     if (layoutObject.hasLayer() && toLayoutBoxModelObject(layoutObject).hasSelfPaintingLayer())
         return *toLayoutBoxModelObject(layoutObject).layer();
 
     return m_enclosingSelfPaintingLayer;
 }
 
 } // namespace blink