Fix caret paint invalidation when moving between blocks

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;
+
   LayoutBlock* newLayoutBlock = caretLayoutBlock(caretPosition.anchorNode());
   if (newLayoutBlock != m_layoutBlock) {
     if (m_layoutBlock)
       m_layoutBlock->setMayNeedPaintInvalidation();
-    m_previousLayoutBlock = m_layoutBlock;
     m_layoutBlock = newLayoutBlock;
-    m_needsPaintInvalidation = true;
-  } else {
-    m_previousLayoutBlock = nullptr;
+    if (newLayoutBlock)
+      m_needsPaintInvalidation = true;
+    m_visualRect = LayoutRect();
   }
 
   if (!newLayoutBlock) {
     m_color = Color();
     m_localRect = LayoutRect();
     return;
   }
 
   Color newColor;
   if (caretPosition.anchorNode()) {
@@ skipping 12 matching lines @@
   }
 
   if (m_needsPaintInvalidation)
     newLayoutBlock->setMayNeedPaintInvalidation();
 }
 
 void CaretDisplayItemClient::invalidatePaintIfNeeded(
     const LayoutBlock& block,
     const PaintInvalidatorContext& context,
     PaintInvalidationReason layoutBlockPaintInvalidationReason) {
-  if (block == m_previousLayoutBlock) {
-    // Invalidate the previous caret if it was in a different block.
-    // m_previousLayoutBlock is set only when it's different from m_layoutBlock.
-    DCHECK(block != m_layoutBlock);
-
-    ObjectPaintInvalidatorWithContext objectInvalidator(*m_previousLayoutBlock,
-                                                        context);
-    if (!isImmediateFullPaintInvalidationReason(
-            layoutBlockPaintInvalidationReason)) {
-      objectInvalidator.fullyInvalidatePaint(PaintInvalidationCaret,
-                                             m_visualRect, LayoutRect());
-    }
-
-    // If m_layoutBlock is not null, the following will be done when
-    // the new caret is invalidated in m_layoutBlock.
-    if (!m_layoutBlock) {

[Xianzhu, 2017/02/17 18:02:58]

The "will be done" assumption was incorrect because m_layoutBlock may be visited
earlier. m_layoutBlock and m_previousLayoutBlock may also in different painting
layer, so line 177 should be executed for both.

-      context.paintingLayer->setNeedsRepaint();
-      objectInvalidator.invalidateDisplayItemClient(*this,
-                                                    PaintInvalidationCaret);
-      m_visualRect = LayoutRect();

[Xianzhu, 2017/02/17 18:02:58]

This is moved into updateStyleAndLayoutIfNeeded(). The previous code may cause
unnecessary paint invalidation of the "previous visual rect in previous block"
on the current block, because m_visualRect may be the visual rect in previous
block.

-      m_needsPaintInvalidation = false;
-    }
-
-    m_previousLayoutBlock = nullptr;
+  if (block == m_layoutBlock) {
+    invalidatePaintInCurrentLayoutBlock(context,
+                                        layoutBlockPaintInvalidationReason);
     return;
   }
 
-  if (block != m_layoutBlock)
-    return;
+  if (block == m_previousLayoutBlock) {
+    invalidatePaintInPreviousLayoutBlock(context,
+                                         layoutBlockPaintInvalidationReason);
+  }
+}
 
-  // Invalidate the new caret, and the old caret if it was in the same block.
+void CaretDisplayItemClient::invalidatePaintInPreviousLayoutBlock(
+    const PaintInvalidatorContext& context,
+    PaintInvalidationReason layoutBlockPaintInvalidationReason) {
+  DCHECK(m_previousLayoutBlock);
+
+  ObjectPaintInvalidatorWithContext objectInvalidator(*m_previousLayoutBlock,
+                                                      context);
+  if (!isImmediateFullPaintInvalidationReason(
+          layoutBlockPaintInvalidationReason)) {
+    objectInvalidator.invalidatePaintUsingContainer(
+        *context.paintInvalidationContainer, m_previousVisualRect,
+        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_layoutBlock && !m_localRect.isEmpty()) {
+  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) {
-    m_needsPaintInvalidation = false;
+  if (!m_needsPaintInvalidation && newVisualRect == m_visualRect)
+    return;
 
-    ObjectPaintInvalidatorWithContext objectInvalidator(*m_layoutBlock,
-                                                        context);
-    if (!isImmediateFullPaintInvalidationReason(
-            layoutBlockPaintInvalidationReason)) {
-      objectInvalidator.fullyInvalidatePaint(PaintInvalidationCaret,
-                                             m_visualRect, newVisualRect);
-    }
+  m_needsPaintInvalidation = false;
 
-    context.paintingLayer->setNeedsRepaint();
-    objectInvalidator.invalidateDisplayItemClient(*this,
-                                                  PaintInvalidationCaret);
+  ObjectPaintInvalidatorWithContext objectInvalidator(*m_layoutBlock, context);
+  if (!isImmediateFullPaintInvalidationReason(
+          layoutBlockPaintInvalidationReason)) {
+    objectInvalidator.fullyInvalidatePaint(PaintInvalidationCaret, m_visualRect,
+                                           newVisualRect);
   }
 
+  context.paintingLayer->setNeedsRepaint();
+  objectInvalidator.invalidateDisplayItemClient(*this, PaintInvalidationCaret);
+
   m_visualRect = newVisualRect;
 }
 
 void CaretDisplayItemClient::paintCaret(
     GraphicsContext& context,
     const LayoutPoint& paintOffset,
     DisplayItem::Type displayItemType) const {
   if (DrawingRecorder::useCachedDrawingIfPossible(context, *this,
                                                   displayItemType))
     return;
 
   LayoutRect drawingRect = m_localRect;
   drawingRect.moveBy(paintOffset);
 
   IntRect paintRect = pixelSnappedIntRect(drawingRect);
   DrawingRecorder drawingRecorder(context, *this, DisplayItem::kCaret,
                                   paintRect);
   context.fillRect(paintRect, m_color);
 }
 
 String CaretDisplayItemClient::debugName() const {
   return "Caret";
 }
 
 LayoutRect CaretDisplayItemClient::visualRect() const {
   return m_visualRect;
 }
 
 }  // namespace blink