Invalidate caret during paint invalidation

third_party/WebKit/Source/core/editing/FrameSelection.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 206 matching lines @@
     notifyLayoutObjectOfSelectionChange(userTriggered);
     return;
   }
 
   const VisibleSelectionTemplate<Strategy> oldSelection =
       visibleSelection<Strategy>();
   const Position& oldSelectionStart = selection().start();
 
   m_handleVisibility = handleVisibility;
   m_selectionEditor->setVisibleSelection(s, options);
-  m_frameCaret->setCaretRectNeedsUpdate();
+  scheduleVisualUpdateForPaintInvalidationIfNeeded();
 
   if (!s.isNone() && !(options & DoNotSetFocus)) {
     setFocusedNodeIfNeeded();
     // |setFocusedNodeIfNeeded()| dispatches sync events "FocusOut" and
     // "FocusIn", |m_frame| may associate to another document.
     if (!isAvailable() || document() != currentDocument) {
       // Once we get test case to reach here, we should change this
       // if-statement to |DCHECK()|.
       NOTREACHED();
       return;
     }
   }
 
   if (!(options & DoNotUpdateAppearance)) {
-    // Hits in
-    // compositing/overflow/do-not-paint-outline-into-composited-scrolling-contents.html
-    DisableCompositingQueryAsserts disabler;
     m_frameCaret->stopCaretBlinkTimer();
     updateAppearance();
   }
 
   // Always clear the x position used for vertical arrow navigation.
   // It will be restored by the vertical arrow navigation code if necessary.
   m_xPosForVerticalArrowNavigation = NoXPosForVerticalArrowNavigation();
   // This may dispatch a synchronous focus-related events.
   selectFrameElementInParentIfFullySelected();
   if (!isAvailable() || document() != currentDocument) {
@@ skipping 124 matching lines @@
   const Position& oldExtent = selection().extent();
   const Position& newExtent =
       computePositionForChildrenRemoval(oldExtent, container);
   if (newStart == oldStart && newEnd == oldEnd && newBase == oldBase &&
       newExtent == oldExtent)
     return;
   if (selection().isBaseFirst())
     m_selectionEditor->setWithoutValidation(newStart, newEnd);
   else
     m_selectionEditor->setWithoutValidation(newEnd, newStart);
-  m_frameCaret->setCaretRectNeedsUpdate();
   if (document().isRunningExecCommand())
     return;
   TypingCommand::closeTyping(m_frame);
 }
 
 void FrameSelection::nodeWillBeRemoved(Node& node) {
   // There can't be a selection inside a fragment, so if a fragment's node is
   // being removed, the selection in the document that created the fragment
   // needs no adjustment.
   if (isNone() || !node.inActiveDocument())
@@ skipping 59 matching lines @@
     // TODO(yosin): We should paint changed area only rather than whole
     // selected range.
     clearLayoutTreeSelection = true;
   }
 
   if (clearLayoutTreeSelection)
     selection().start().document()->layoutViewItem().clearSelection();
 
   if (clearDOMTreeSelection)
     setSelection(SelectionInDOMTree(), DoNotSetFocus);
-  m_frameCaret->setCaretRectNeedsUpdate();
 
   // TODO(yosin): We should move to call |TypingCommand::closeTyping()| to
   // |Editor| class.
   if (!document().isRunningExecCommand())
     TypingCommand::closeTyping(m_frame);
 }
 
 static Position updatePositionAfterAdoptingTextReplacement(
     const Position& position,
     CharacterData* node,
@@ skipping 190 matching lines @@
       CloseTyping | ClearTypingStyle | userTriggered;
   setSelection(selectionModifier.selection(), options);
 
   if (granularity == LineGranularity || granularity == ParagraphGranularity)
     m_xPosForVerticalArrowNavigation =
         selectionModifier.xPosForVerticalArrowNavigation();
 
   if (userTriggered == UserTriggered)
     m_granularity = CharacterGranularity;
 
-  m_frameCaret->setCaretRectNeedsUpdate();
+  scheduleVisualUpdateForPaintInvalidationIfNeeded();
 
   return true;
 }
 
 bool FrameSelection::modify(EAlteration alter,
                             unsigned verticalDistance,
                             VerticalDirection direction) {
   SelectionModifier selectionModifier(*frame(), selection());
   if (!selectionModifier.modifyWithPageGranularity(alter, verticalDistance,
                                                    direction)) {
@@ skipping 14 matching lines @@
   m_granularity = CharacterGranularity;
   if (m_granularityStrategy)
     m_granularityStrategy->Clear();
   setSelection(SelectionInDOMTree());
 }
 
 void FrameSelection::documentAttached(Document* document) {
   DCHECK(document);
   m_useSecureKeyboardEntryWhenActive = false;
   m_selectionEditor->documentAttached(document);
-  m_frameCaret->documentAttached(document);
   setContext(document);
 }
 
 void FrameSelection::contextDestroyed(Document* document) {
   m_granularity = CharacterGranularity;
 
   LayoutViewItem view = m_frame->contentLayoutItem();
   if (!view.isNull())
     view.clearSelection();
 
   m_frame->editor().clearTypingStyle();
   m_selectionEditor->documentDetached(*document);
 }
 
-bool FrameSelection::hasCaretIn(const LayoutBlock& layoubBlock) const {
+void FrameSelection::clearPreviousCaretVisualRect(const LayoutBlock& block) {
+  m_frameCaret->clearPreviousVisualRect(block);
+}
+
+void FrameSelection::layoutBlockWillBeDestroyed(const LayoutBlock& block) {
+  m_frameCaret->layoutBlockWillBeDestroyed(block);
+}
+
+void FrameSelection::updateStyleAndLayoutIfNeeded() {
+  m_frameCaret->updateStyleAndLayoutIfNeeded();
+}
+
+void FrameSelection::invalidatePaintIfNeeded(
+    const LayoutBlock& block,
+    const PaintInvalidatorContext& context,
+    PaintInvalidationReason reason) {
+  m_frameCaret->invalidatePaintIfNeeded(block, context, reason);
+}
+
+bool FrameSelection::shouldPaintCaret(const LayoutBlock& block) const {
   DCHECK(selection().isValidFor(document()));
-  if (!isCaret())
-    return false;
-  return CaretDisplayItemClient::caretLayoutObject(
-             selection().start().anchorNode()) == layoubBlock &&
-         hasEditableStyle();
+
+  bool result = m_frameCaret->shouldPaintCaret(block);
+  DCHECK(!result || (isCaret() && hasEditableStyle()));
+  return result;
 }
 
 IntRect FrameSelection::absoluteCaretBounds() {
   DCHECK(selection().isValidFor(*m_frame->document()));
   return m_frameCaret->absoluteCaretBounds();
 }
 
-void FrameSelection::invalidateCaretRect(bool forceInvalidation) {
-  m_frameCaret->invalidateCaretRect(forceInvalidation);
-}
-
-void FrameSelection::dataWillChange(const CharacterData& node) {
-  m_frameCaret->dataWillChange(node);
-}
-
 void FrameSelection::paintCaret(GraphicsContext& context,
                                 const LayoutPoint& paintOffset) {
   m_frameCaret->paintCaret(context, paintOffset);
 }
 
 bool FrameSelection::contains(const LayoutPoint& point) {
   if (document().layoutViewItem().isNull())
     return false;
 
   // Treat a collapsed selection like no selection.
@@ skipping 282 matching lines @@
 
 bool FrameSelection::isAppearanceDirty() const {
   return m_pendingSelection->hasPendingSelection();
 }
 
 void FrameSelection::commitAppearanceIfNeeded(LayoutView& layoutView) {
   return m_pendingSelection->commit(layoutView);
 }
 
 void FrameSelection::didLayout() {
-  setCaretRectNeedsUpdate();
   updateAppearance();
 }
 
 void FrameSelection::updateAppearance() {
   m_frameCaret->updateAppearance();
 
   if (m_frame->contentLayoutItem().isNull())
     return;
   m_pendingSelection->setHasPendingSelection();
 }
@@ skipping 239 matching lines @@
   visitor->trace(m_selectionEditor);
   visitor->trace(m_frameCaret);
   SynchronousMutationObserver::trace(visitor);
 }
 
 void FrameSelection::scheduleVisualUpdate() const {
   if (Page* page = m_frame->page())
     page->animator().scheduleVisualUpdate(m_frame->localFrameRoot());
 }
 
+void FrameSelection::scheduleVisualUpdateForPaintInvalidationIfNeeded() const {
+  if (FrameView* frameView = m_frame->view())
+    frameView->scheduleVisualUpdateForPaintInvalidationIfNeeded();
+}
+
 bool FrameSelection::selectWordAroundPosition(const VisiblePosition& position) {
   static const EWordSide wordSideList[2] = {RightWordIfOnBoundary,
                                             LeftWordIfOnBoundary};
   for (EWordSide wordSide : wordSideList) {
     VisiblePosition start = startOfWord(position, wordSide);
     VisiblePosition end = endOfWord(position, wordSide);
     String text =
         plainText(EphemeralRange(start.deepEquivalent(), end.deepEquivalent()));
     if (!text.isEmpty() && !isSeparator(text.characterStartingAt(0))) {
       setSelection(SelectionInDOMTree::Builder()
@@ skipping 69 matching lines @@
 void FrameSelection::updateIfNeeded() {
   DCHECK(!m_frame->document()->needsLayoutTreeUpdate());
   m_selectionEditor->updateIfNeeded();
 }
 
 void FrameSelection::setCaretVisible(bool caretIsVisible) {
   m_frameCaret->setCaretVisibility(caretIsVisible ? CaretVisibility::Visible
                                                   : CaretVisibility::Hidden);
 }
 
-bool FrameSelection::shouldPaintCaretForTesting() const {
-  return m_frameCaret->shouldPaintCaretForTesting();
-}
-
-bool FrameSelection::isPreviousCaretDirtyForTesting() const {
-  return m_frameCaret->isPreviousCaretDirtyForTesting();
-}
-
-void FrameSelection::setCaretRectNeedsUpdate() {
-  m_frameCaret->setCaretRectNeedsUpdate();
-}
-
 void FrameSelection::setCaretBlinkingSuspended(bool suspended) {
   m_frameCaret->setCaretBlinkingSuspended(suspended);
 }
 
 bool FrameSelection::isCaretBlinkingSuspended() const {
   return m_frameCaret->isCaretBlinkingSuspended();
 }
 
 }  // namespace blink
 
 #ifndef NDEBUG
 
 void showTree(const blink::FrameSelection& sel) {
   sel.showTreeForThis();
 }
 
 void showTree(const blink::FrameSelection* sel) {
   if (sel)
     sel->showTreeForThis();
   else
     LOG(INFO) << "Cannot showTree for <null> FrameSelection.";
 }
 
 #endif