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;
+  // We should save m_previousLayoutBlock and m_visualRectInPreviousLayoutBlock
+  // only if they have not been saved since the last paint invalidation.

[chrishtr, 2017/03/08 17:36:06]

This conditional is needed because there may be multiple layouts between
paint invalidations, right? If so, worth commenting to that effect.

And it seems this is unique to carets because they can be reparented without
an eager invalidation?

[Xianzhu, 2017/03/08 19:38:22]

Yes. Added comment.
Yes. Carets are also unique because they are managed by frames, but the
containing blocks invalidate and paint them.

+  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 43 matching lines @@
 void CaretDisplayItemClient::invalidatePaintInPreviousLayoutBlock(
     const PaintInvalidatorContext& context,
     PaintInvalidationReason layoutBlockPaintInvalidationReason) {
   DCHECK(m_previousLayoutBlock);
 
   ObjectPaintInvalidatorWithContext objectInvalidator(*m_previousLayoutBlock,
                                                       context);
   if (!isImmediateFullPaintInvalidationReason(
           layoutBlockPaintInvalidationReason)) {
     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) {
   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 (isImmediateFullPaintInvalidationReason(
+            layoutBlockPaintInvalidationReason)) {
+      objectInvalidator.invalidateDisplayItemClient(*this,
+                                                    PaintInvalidationCaret);
+    }
     return;
+  }
 
   m_needsPaintInvalidation = false;
 
-  ObjectPaintInvalidatorWithContext objectInvalidator(*m_layoutBlock, context);
   if (!isImmediateFullPaintInvalidationReason(
           layoutBlockPaintInvalidationReason)) {
     objectInvalidator.fullyInvalidatePaint(PaintInvalidationCaret, m_visualRect,
                                            newVisualRect);
   }
 
   context.paintingLayer->setNeedsRepaint();
   objectInvalidator.invalidateDisplayItemClient(*this, PaintInvalidationCaret);
 
   m_visualRect = newVisualRect;
@@ skipping 18 matching lines @@
 
 String CaretDisplayItemClient::debugName() const {
   return "Caret";
 }
 
 LayoutRect CaretDisplayItemClient::visualRect() const {
   return m_visualRect;
 }
 
 }  // namespace blink