Fix caret paint invalidation issues

third_party/WebKit/Source/core/editing/CaretDisplayItemClient.cpp

 /*
  * Copyright (C) 2004, 2008, 2009, 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 99 matching lines @@
   LayoutBlockItem caretPainterItem =
       LayoutBlockItem(caretLayoutBlock(caretPosition.anchorNode()));
   LayoutRect caretLocalRectWithWritingMode = caretLocalRect;
   caretPainterItem.flipForWritingMode(caretLocalRectWithWritingMode);
   return mapCaretRectToCaretPainter(LayoutItem(layoutObject), caretPainterItem,
                                     caretLocalRectWithWritingMode);
 }
 
 void CaretDisplayItemClient::updateStyleAndLayoutIfNeeded(
     const PositionWithAffinity& caretPosition) {
-  m_previousLayoutBlock = m_layoutBlock;
-  m_previousVisualRect = m_visualRect;
+  // This method may be called multiple times (e.g. in partial lifecycle
+  // updates) before a paint invalidation. We should save m_previousLayoutBlock
+  // and m_visualRectInPreviousLayoutBlock only if they have not been saved
+  // since the last paint invalidation to ensure the caret painted in the
+  // previous paint invalidated block will be invalidated. We don't care about
+  // intermediate changes of layoutBlock because they are not painted.
+  if (!m_previousLayoutBlock) {
+    m_previousLayoutBlock = m_layoutBlock;
+    m_visualRectInPreviousLayoutBlock = m_visualRect;
+  }
 
   LayoutBlock* newLayoutBlock = caretLayoutBlock(caretPosition.anchorNode());
   if (newLayoutBlock != m_layoutBlock) {
     if (m_layoutBlock)
       m_layoutBlock->setMayNeedPaintInvalidation();
     m_layoutBlock = newLayoutBlock;
     if (newLayoutBlock)
       m_needsPaintInvalidation = true;
     m_visualRect = LayoutRect();
   }
@@ skipping 19 matching lines @@
     m_needsPaintInvalidation = true;
     m_localRect = newLocalRect;
   }
 
   if (m_needsPaintInvalidation)
     newLayoutBlock->setMayNeedPaintInvalidation();
 }
 
 void CaretDisplayItemClient::invalidatePaintIfNeeded(
     const LayoutBlock& block,
-    const PaintInvalidatorContext& context,
-    PaintInvalidationReason layoutBlockPaintInvalidationReason) {
+    const PaintInvalidatorContext& context) {
   if (block == m_layoutBlock) {
-    invalidatePaintInCurrentLayoutBlock(context,
-                                        layoutBlockPaintInvalidationReason);
+    invalidatePaintInCurrentLayoutBlock(context);
     return;
   }
 
-  if (block == m_previousLayoutBlock) {
-    invalidatePaintInPreviousLayoutBlock(context,
-                                         layoutBlockPaintInvalidationReason);
-  }
+  if (block == m_previousLayoutBlock)
+    invalidatePaintInPreviousLayoutBlock(context);
 }
 
 void CaretDisplayItemClient::invalidatePaintInPreviousLayoutBlock(
-    const PaintInvalidatorContext& context,
-    PaintInvalidationReason layoutBlockPaintInvalidationReason) {
+    const PaintInvalidatorContext& context) {
   DCHECK(m_previousLayoutBlock);
 
   ObjectPaintInvalidatorWithContext objectInvalidator(*m_previousLayoutBlock,
                                                       context);
   if (!isImmediateFullPaintInvalidationReason(
-          layoutBlockPaintInvalidationReason)) {
+          m_previousLayoutBlock->fullPaintInvalidationReason())) {
     objectInvalidator.invalidatePaintRectangleWithContext(
-        m_previousVisualRect, PaintInvalidationCaret);
+        m_visualRectInPreviousLayoutBlock, PaintInvalidationCaret);
   }
 
   context.paintingLayer->setNeedsRepaint();
   objectInvalidator.invalidateDisplayItemClient(*this, PaintInvalidationCaret);
   m_previousLayoutBlock = nullptr;
 }
 
 void CaretDisplayItemClient::invalidatePaintInCurrentLayoutBlock(
-    const PaintInvalidatorContext& context,
-    PaintInvalidationReason layoutBlockPaintInvalidationReason) {
+    const PaintInvalidatorContext& context) {
   DCHECK(m_layoutBlock);
 
   LayoutRect newVisualRect;
   if (!m_localRect.isEmpty()) {
     newVisualRect = m_localRect;
     context.mapLocalRectToPaintInvalidationBacking(*m_layoutBlock,
                                                    newVisualRect);
     newVisualRect.move(m_layoutBlock->scrollAdjustmentForPaintInvalidation(
         *context.paintInvalidationContainer));
 
     if (m_layoutBlock->usesCompositedScrolling()) {
       // The caret should use scrolling coordinate space.
       DCHECK(m_layoutBlock == context.paintInvalidationContainer);
       newVisualRect.move(LayoutSize(m_layoutBlock->scrolledContentOffset()));
     }
   }
 
-  if (!m_needsPaintInvalidation && newVisualRect == m_visualRect)
+  if (m_layoutBlock == m_previousLayoutBlock)
+    m_previousLayoutBlock = nullptr;
+
+  ObjectPaintInvalidatorWithContext objectInvalidator(*m_layoutBlock, context);
+  if (!m_needsPaintInvalidation && newVisualRect == m_visualRect) {
+    // The caret may change paint offset without changing visual rect, and we
+    // need to invalidate the display item client if the block is doing full
+    // paint invalidation.
+    if (isImmediateFullPaintInvalidationReason(
+            m_layoutBlock->fullPaintInvalidationReason()) ||
+        // For non-SPv2, ForcedSubtreeInvalidationChecking may hint change of
+        // paint offset. See ObjectPaintInvalidatorWithContext::
+        // invalidatePaintIfNeededWithComputedReason().
+        (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
+         (context.forcedSubtreeInvalidationFlags &
+          PaintInvalidatorContext::ForcedSubtreeInvalidationChecking))) {
+      objectInvalidator.invalidateDisplayItemClient(*this,
+                                                    PaintInvalidationCaret);
+    }
     return;
+  }
 
   m_needsPaintInvalidation = false;
 
-  ObjectPaintInvalidatorWithContext objectInvalidator(*m_layoutBlock, context);
   if (!isImmediateFullPaintInvalidationReason(
-          layoutBlockPaintInvalidationReason)) {
+          m_layoutBlock->fullPaintInvalidationReason())) {
     objectInvalidator.fullyInvalidatePaint(PaintInvalidationCaret, m_visualRect,
                                            newVisualRect);
   }
 
   context.paintingLayer->setNeedsRepaint();
   objectInvalidator.invalidateDisplayItemClient(*this, PaintInvalidationCaret);
 
   m_visualRect = newVisualRect;
 }
 
@@ skipping 16 matching lines @@
 
 String CaretDisplayItemClient::debugName() const {
   return "Caret";
 }
 
 LayoutRect CaretDisplayItemClient::visualRect() const {
   return m_visualRect;
 }
 
 }  // namespace blink