Invalidate caret during paint invalidation

third_party/WebKit/Source/core/editing/FrameCaret.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 21 matching lines @@
 #include "core/editing/SelectionEditor.h"
 #include "core/editing/commands/CompositeEditCommand.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/TextControlElement.h"
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/api/LayoutPartItem.h"
 #include "core/page/Page.h"
-#include "core/paint/PaintLayer.h"
 #include "public/platform/WebTraceLocation.h"
 
 namespace blink {
 
 FrameCaret::FrameCaret(LocalFrame& frame,
                        const SelectionEditor& selectionEditor)
     : m_selectionEditor(&selectionEditor),
       m_frame(frame),
       m_caretBase(new CaretDisplayItemClient()),
       m_caretVisibility(CaretVisibility::Hidden),
-      m_previousCaretVisibility(CaretVisibility::Hidden),
       m_caretBlinkTimer(TaskRunnerHelper::get(TaskType::UnspecedTimer, &frame),
                         this,
                         &FrameCaret::caretBlinkTimerFired),
-      m_caretRectDirty(true),
       m_shouldPaintCaret(true),
       m_isCaretBlinkingSuspended(false),
       m_shouldShowBlockCursor(false) {}
 
 FrameCaret::~FrameCaret() = default;
 
 DEFINE_TRACE(FrameCaret) {
   visitor->trace(m_selectionEditor);
   visitor->trace(m_frame);
-  visitor->trace(m_previousCaretNode);
-  visitor->trace(m_previousCaretAnchorNode);
-  SynchronousMutationObserver::trace(visitor);
 }
 
-void FrameCaret::documentAttached(Document* document) {
-  setContext(document);
+const DisplayItemClient& FrameCaret::displayItemClient() const {
+  return *m_caretBase;
 }
 
 const PositionWithAffinity FrameCaret::caretPosition() const {
   const VisibleSelection& selection =
       m_selectionEditor->visibleSelection<EditingStrategy>();
   if (!selection.isCaret())
     return PositionWithAffinity();
   return PositionWithAffinity(selection.start(), selection.affinity());
 }
 
-const DisplayItemClient& FrameCaret::displayItemClient() const {
-  return *m_caretBase;
-}
-
 inline static bool shouldStopBlinkingDueToTypingCommand(LocalFrame* frame) {
   return frame->editor().lastEditCommand() &&
          frame->editor().lastEditCommand()->shouldStopCaretBlinking();
 }
 
 void FrameCaret::updateAppearance() {
   // Paint a block cursor instead of a caret in overtype mode unless the caret
   // is at the end of a line (in this case the FrameSelection will paint a
   // blinking caret as usual).
   bool paintBlockCursor = m_shouldShowBlockCursor && isActive();
@@ skipping 16 matching lines @@
     stopCaretBlinkTimer();
 
   // Start blinking with a black caret. Be sure not to restart if we're
   // already blinking in the right location.
   if (shouldBlink)
     startBlinkCaret();
 }
 
 void FrameCaret::stopCaretBlinkTimer() {
   if (m_caretBlinkTimer.isActive() || m_shouldPaintCaret)
-    setCaretRectNeedsUpdate();
+    setNeedsPaintInvalidation();
   m_shouldPaintCaret = false;
   m_caretBlinkTimer.stop();
 }
 
 void FrameCaret::startBlinkCaret() {
   // Start blinking with a black caret. Be sure not to restart if we're
   // already blinking in the right location.
   if (m_caretBlinkTimer.isActive())
     return;
 
   if (double blinkInterval = LayoutTheme::theme().caretBlinkInterval())
     m_caretBlinkTimer.startRepeating(blinkInterval, BLINK_FROM_HERE);
 
   m_shouldPaintCaret = true;
-  setCaretRectNeedsUpdate();
+  setNeedsPaintInvalidation();
 }
 
 void FrameCaret::setCaretVisibility(CaretVisibility visibility) {
   if (m_caretVisibility == visibility)
     return;
 
   m_caretVisibility = visibility;
 
   updateAppearance();
+  setNeedsPaintInvalidation();
 }
 
-void FrameCaret::setCaretRectNeedsUpdate() {
-  if (m_caretRectDirty)
-    return;
-  m_caretRectDirty = true;
+void FrameCaret::setNeedsPaintInvalidation() {
+  m_caretBase->setNeedsPaintInvalidation();
+  if (FrameView* frameView = m_frame->view())
+    frameView->scheduleVisualUpdateForPaintInvalidationIfNeeded();
+}
 
-  if (Page* page = m_frame->page())
-    page->animator().scheduleVisualUpdate(m_frame->localFrameRoot());
+void FrameCaret::clearPreviousVisualRect(const LayoutBlock& block) {
+  m_caretBase->clearPreviousVisualRect(block);
+}
 
-  // Ensure the frame will be checked for paint invalidation during
-  // PrePaintTreeWalk.
-  if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled()) {
-    if (auto layoutItem = m_frame->ownerLayoutItem())
-      layoutItem.setMayNeedPaintInvalidation();
-  }
+void FrameCaret::layoutBlockWillBeDestroyed(const LayoutBlock& block) {
+  m_caretBase->layoutBlockWillBeDestroyed(block);
+}
+
+void FrameCaret::updateForPaintInvalidation() {
+  bool shouldPaintCaret =
+      m_shouldPaintCaret && isActive() &&
+      m_caretVisibility == CaretVisibility::Visible &&
+      m_selectionEditor->visibleSelection<EditingStrategy>().hasEditableStyle();
+
+  m_caretBase->updateForPaintInvalidation(
+      shouldPaintCaret ? caretPosition() : PositionWithAffinity());
+}
+
+void FrameCaret::invalidatePaintIfNeeded(const LayoutBlock& block,
+                                         const PaintInvalidatorContext& context,
+                                         PaintInvalidationReason reason) {
+  m_caretBase->invalidatePaintIfNeeded(block, context, reason);
 }
 
 bool FrameCaret::caretPositionIsValidForDocument(
     const Document& document) const {
   if (!isActive())
     return true;
 
   return caretPosition().document() == document && !caretPosition().isOrphan();
 }
 
-static bool shouldRepaintCaret(Node& node) {
-  // If PositionAnchorType::BeforeAnchor or PositionAnchorType::AfterAnchor,
-  // carets need to be repainted not only when the node is contentEditable but
-  // also when its parentNode() is contentEditable.
-  node.document().updateStyleAndLayoutTree();
-  return hasEditableStyle(node) ||
-         (node.parentNode() && hasEditableStyle(*node.parentNode()));
-}
-
-void FrameCaret::invalidateCaretRect(bool forceInvalidation) {
-  if (!m_caretRectDirty)
-    return;
-  m_caretRectDirty = false;
-
-  DCHECK(caretPositionIsValidForDocument(*m_frame->document()));
-  LayoutObject* layoutObject = nullptr;
-  LayoutRect newRect;
-  PositionWithAffinity currentCaretPosition = caretPosition();
-  if (isActive())
-    newRect = localCaretRectOfPosition(currentCaretPosition, layoutObject);
-  Node* newNode = layoutObject ? layoutObject->node() : nullptr;
-  // The current selected node |newNode| could be a child multiple levels below
-  // its associated "anchor node" ancestor, so we reference and keep around the
-  // anchor node for checking editability.
-  // TODO(wkorman): Consider storing previous Position, rather than Node, and
-  // making use of EditingUtilies::isEditablePosition() directly.
-  Node* newAnchorNode =
-      currentCaretPosition.position().parentAnchoredEquivalent().anchorNode();
-  if (newNode && newAnchorNode && newNode != newAnchorNode &&
-      newAnchorNode->layoutObject() && newAnchorNode->layoutObject()->isBox()) {
-    newNode->layoutObject()->mapToVisualRectInAncestorSpace(
-        toLayoutBoxModelObject(newAnchorNode->layoutObject()), newRect);
-  }
-  // It's possible for the timer to be inactive even though we want to
-  // invalidate the caret. For example, when running as a layout test the
-  // caret blink interval could be zero and thus |m_caretBlinkTimer| will
-  // never be started. We provide |forceInvalidation| for use by paint
-  // invalidation internals where we need to invalidate the caret regardless
-  // of timer state.
-  if (!forceInvalidation && !m_caretBlinkTimer.isActive() &&
-      newNode == m_previousCaretNode && newRect == m_previousCaretRect &&
-      m_caretVisibility == m_previousCaretVisibility)
-    return;
-
-  if (m_previousCaretAnchorNode &&
-      shouldRepaintCaret(*m_previousCaretAnchorNode)) {
-    m_caretBase->invalidateLocalCaretRect(m_previousCaretAnchorNode.get(),
-                                          m_previousCaretRect);
-  }
-  if (newAnchorNode && shouldRepaintCaret(*newAnchorNode))
-    m_caretBase->invalidateLocalCaretRect(newAnchorNode, newRect);
-  m_previousCaretNode = newNode;
-  m_previousCaretAnchorNode = newAnchorNode;
-  m_previousCaretRect = newRect;
-  m_previousCaretVisibility = m_caretVisibility;
-}
-
 static IntRect absoluteBoundsForLocalRect(Node* node, const LayoutRect& rect) {
-  LayoutBlock* caretPainter = CaretDisplayItemClient::caretLayoutObject(node);
+  LayoutBlock* caretPainter = CaretDisplayItemClient::caretLayoutBlock(node);
   if (!caretPainter)
     return IntRect();
 
   LayoutRect localRect(rect);
   caretPainter->flipForWritingMode(localRect);
   return caretPainter->localToAbsoluteQuad(FloatRect(localRect))
       .enclosingBoundingBox();
 }
 
 IntRect FrameCaret::absoluteCaretBounds() const {
@@ skipping 20 matching lines @@
 }
 
 void FrameCaret::setShouldShowBlockCursor(bool shouldShowBlockCursor) {
   m_shouldShowBlockCursor = shouldShowBlockCursor;
 
   m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   updateAppearance();
 }
 
-void FrameCaret::paintCaret(GraphicsContext& context,
-                            const LayoutPoint& paintOffset) {
-  if (m_caretVisibility == CaretVisibility::Hidden)
-    return;
-
-  if (!(isActive() && m_shouldPaintCaret))
-    return;
-
-  const LayoutRect caretLocalRect =
-      CaretDisplayItemClient::computeCaretRect(caretPosition());
-  m_caretBase->paintCaret(caretPosition().anchorNode(), context, caretLocalRect,
-                          paintOffset, DisplayItem::kCaret);
+bool FrameCaret::shouldPaintCaret(const LayoutBlock& block) const {
+  return m_caretBase->shouldPaintCaret(block);
 }
 
-void FrameCaret::dataWillChange(const CharacterData& node) {
-  if (node == m_previousCaretNode) {
-    // This invalidation is eager, and intentionally uses stale state.
-    DisableCompositingQueryAsserts disabler;
-    m_caretBase->invalidateLocalCaretRect(m_previousCaretAnchorNode.get(),
-                                          m_previousCaretRect);
-  }
-}
-
-void FrameCaret::nodeWillBeRemoved(Node& node) {
-  if (node != m_previousCaretNode && node != m_previousCaretAnchorNode)
-    return;
-  // Hits in ManualTests/caret-paint-after-last-text-is-removed.html
-  DisableCompositingQueryAsserts disabler;
-  m_caretBase->invalidateLocalCaretRect(m_previousCaretAnchorNode.get(),
-                                        m_previousCaretRect);
-  m_previousCaretNode = nullptr;
-  m_previousCaretAnchorNode = nullptr;
-  m_previousCaretRect = LayoutRect();
-  m_previousCaretVisibility = CaretVisibility::Hidden;
-}
-
-void FrameCaret::contextDestroyed(Document*) {
-  m_caretBlinkTimer.stop();
-  m_previousCaretNode.clear();
-  m_previousCaretAnchorNode.clear();
+void FrameCaret::paintCaret(GraphicsContext& context,
+                            const LayoutPoint& paintOffset) const {
+  m_caretBase->paintCaret(context, paintOffset, DisplayItem::kCaret);
 }
 
 bool FrameCaret::shouldBlinkCaret() const {
   if (m_caretVisibility != CaretVisibility::Visible || !isActive())
     return false;
 
   Element* root = rootEditableElementOf(caretPosition().position());
   if (!root)
     return false;
 
   Element* focusedElement = root->document().focusedElement();
   if (!focusedElement)
     return false;
 
   return focusedElement->isShadowIncludingInclusiveAncestorOf(
       caretPosition().anchorNode());
 }
 
 void FrameCaret::caretBlinkTimerFired(TimerBase*) {
   DCHECK_EQ(m_caretVisibility, CaretVisibility::Visible);
   if (isCaretBlinkingSuspended() && m_shouldPaintCaret)
     return;
   m_shouldPaintCaret = !m_shouldPaintCaret;
-  setCaretRectNeedsUpdate();
+  setNeedsPaintInvalidation();
 }
 
 }  // namespace blink