[Editing][CodeHealth] Extract new FrameCaret class from FrameSelection

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 21 matching lines @@
 #include "core/dom/AXObjectCache.h"
 #include "core/dom/CharacterData.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/Text.h"
 #include "core/editing/CaretBase.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
+#include "core/editing/FrameCaret.h"
 #include "core/editing/GranularityStrategy.h"
 #include "core/editing/InputMethodController.h"
 #include "core/editing/PendingSelection.h"
 #include "core/editing/RenderedPosition.h"
 #include "core/editing/SelectionController.h"
 #include "core/editing/SelectionEditor.h"
 #include "core/editing/SelectionModifier.h"
 #include "core/editing/TextAffinity.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/commands/TypingCommand.h"
@@ skipping 39 matching lines @@
 {
     return !frame || frame->editor().behavior().shouldConsiderSelectionAsDirectional();
 }
 
 FrameSelection::FrameSelection(LocalFrame* frame)
     : m_frame(frame)
     , m_pendingSelection(PendingSelection::create(*this))
     , m_selectionEditor(SelectionEditor::create(*this))
     , m_granularity(CharacterGranularity)
     , m_xPosForVerticalArrowNavigation(NoXPosForVerticalArrowNavigation())
-    , m_previousCaretVisibility(CaretVisibility::Hidden)
-    , m_caretBlinkTimer(this, &FrameSelection::caretBlinkTimerFired)
-    , m_caretRectDirty(true)
-    , m_shouldPaintCaret(true)
-    , m_isCaretBlinkingSuspended(false)
     , m_focused(frame && frame->page() && frame->page()->focusController().focusedFrame() == frame)
     , m_shouldShowBlockCursor(false)
-    , m_caretBase(adoptPtr(new CaretBase))
+    , m_frameCaret(new FrameCaret(frame))
 {
     // TODO(yosin): We should remove null check for |m_frame| in
     // "FrameSelection.cpp", since it never be null.
     DCHECK(frame);
     if (shouldAlwaysUseDirectionalSelection(m_frame))
         m_selectionEditor->setIsDirectional(true);
 }
 
 FrameSelection::~FrameSelection()
 {
@@ skipping 213 matching lines @@
 
     m_selectionEditor->setVisibleSelection(s, options);
     setCaretRectNeedsUpdate();
 
     if (!s.isNone() && !(options & DoNotSetFocus))
         setFocusedNodeIfNeeded();
 
     if (!(options & DoNotUpdateAppearance)) {
         // Hits in compositing/overflow/do-not-paint-outline-into-composited-scrolling-contents.html
         DisableCompositingQueryAsserts disabler;
-        stopCaretBlinkTimer();
+        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();
     notifyLayoutObjectOfSelectionChange(userTriggered);
     // If the selections are same in the DOM tree but not in the flat tree,
@@ skipping 41 matching lines @@
     if (position.anchorNode() == node)
         return true;
 
     if (!node.isElementNode())
         return false;
 
     Element& element = toElement(node);
     return element.isShadowIncludingInclusiveAncestorOf(position.anchorNode());
 }
 
+// TODO(yoiciho): We should move this function to FrameCaret.cpp
+void FrameCaret::nodeWillBeRemoved(Node& node)
+{
+    if (node != m_previousCaretNode)
+        return;
+    // Hits in ManualTests/caret-paint-after-last-text-is-removed.html
+    DisableCompositingQueryAsserts disabler;
+    invalidateLocalCaretRect(m_previousCaretNode.get(), m_previousCaretRect);
+    m_previousCaretNode = nullptr;
+    m_previousCaretRect = LayoutRect();
+    m_previousCaretVisibility = CaretVisibility::Hidden;
+}
+
 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())
         return;
 
     respondToNodeModification(node, removingNodeRemovesPosition(node, selection().base()), removingNodeRemovesPosition(node, selection().extent()),
         removingNodeRemovesPosition(node, selection().start()), removingNodeRemovesPosition(node, selection().end()));
 
-    if (node == m_previousCaretNode) {
-        // Hits in ManualTests/caret-paint-after-last-text-is-removed.html
-        DisableCompositingQueryAsserts disabler;
-        m_caretBase->invalidateLocalCaretRect(m_previousCaretNode.get(), m_previousCaretRect);
-        m_previousCaretNode = nullptr;
-        m_previousCaretRect = LayoutRect();
-        m_previousCaretVisibility = CaretVisibility::Hidden;
-    }
+    m_frameCaret->nodeWillBeRemoved(node);
 }
 
 static bool intersectsNode(const VisibleSelection& selection, Node* node)
 {
     if (selection.isNone())
         return false;
     Position start = selection.start().parentAnchoredEquivalent();
     Position end = selection.end().parentAnchoredEquivalent();
     TrackExceptionState exceptionState;
     // TODO(yosin) We should avoid to use |Range::intersectsNode()|.
@@ skipping 195 matching lines @@
 
     const SetSelectionOptions options = CloseTyping | ClearTypingStyle | userTriggered;
     setSelection(selectionModifier.selection(), options);
 
     if (granularity == LineGranularity || granularity == ParagraphGranularity)
         m_xPosForVerticalArrowNavigation = selectionModifier.xPosForVerticalArrowNavigation();
 
     if (userTriggered == UserTriggered)
         m_granularity = CharacterGranularity;
 
-    setCaretRectNeedsUpdate();
+    m_frameCaret->setCaretRectNeedsUpdate();
 
     return true;
 }
 
 bool FrameSelection::modify(EAlteration alter, unsigned verticalDistance, VerticalDirection direction, EUserTriggered userTriggered, CursorAlignOnScroll align)
 {
     SelectionModifier selectionModifier(*frame(), selection());
     if (!selectionModifier.modifyWithPageGranularity(alter, verticalDistance, direction))
         return false;
 
@@ skipping 10 matching lines @@
 }
 
 void FrameSelection::clear()
 {
     m_granularity = CharacterGranularity;
     if (m_granularityStrategy)
         m_granularityStrategy->Clear();
     setSelection(VisibleSelection());
 }
 
+// TODO(yoiciho): We should move this function to FrameCaret.cpp
+void FrameCaret::prepareForDestruction()
+{
+    m_caretBlinkTimer.stop();
+    m_previousCaretNode.clear();
+}
+
 void FrameSelection::prepareForDestruction()
 {
     m_granularity = CharacterGranularity;
 
-    m_caretBlinkTimer.stop();
-
     LayoutViewItem view = m_frame->contentLayoutItem();
     if (!view.isNull())
         view.clearSelection();
 
     setSelection(VisibleSelection(), CloseTyping | ClearTypingStyle | DoNotUpdateAppearance);
     m_selectionEditor->dispose();
-    m_previousCaretNode.clear();
+    m_frameCaret->prepareForDestruction();
 }
 
 void FrameSelection::setBase(const VisiblePosition &pos, EUserTriggered userTriggered)
 {
     const bool selectionHasDirection = true;
     setSelection(VisibleSelection(pos.deepEquivalent(), selection().extent(), pos.affinity(), selectionHasDirection), CloseTyping | ClearTypingStyle | userTriggered);
 }
 
 void FrameSelection::setExtent(const VisiblePosition &pos, EUserTriggered userTriggered)
 {
     const bool selectionHasDirection = true;
     setSelection(VisibleSelection(selection().base(), pos.deepEquivalent(), pos.affinity(), selectionHasDirection), CloseTyping | ClearTypingStyle | userTriggered);
 }
 
 static bool isTextFormControl(const VisibleSelection& selection)
 {
     return enclosingTextFormControl(selection.start());
 }
 
 LayoutBlock* FrameSelection::caretLayoutObject() const
 {
     DCHECK(selection().isValidFor(*m_frame->document()));
     if (!isCaret())
         return nullptr;
     return CaretBase::caretLayoutObject(selection().start().anchorNode());
 }
 
+// TODO(yoichio): All of functionality should be in FrameCaret.
+// FrameCaret should have PositionWithAffnity and FrameSelection set in
+// setSelecitonAlgorithm.
 IntRect FrameSelection::absoluteCaretBounds()
 {
     DCHECK(selection().isValidFor(*m_frame->document()));
     DCHECK_NE(m_frame->document()->lifecycle().state(), DocumentLifecycle::InPaintInvalidation);
     m_frame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
     if (!isCaret()) {
-        m_caretBase->clearCaretRect();
+        m_frameCaret->clearCaretRect();
     } else {
         if (isTextFormControl(selection()))
-            m_caretBase->updateCaretRect(PositionWithAffinity(isVisuallyEquivalentCandidate(selection().start()) ? selection().start() : Position(), selection().affinity()));
+            m_frameCaret->updateCaretRect(PositionWithAffinity(isVisuallyEquivalentCandidate(selection().start()) ? selection().start() : Position(), selection().affinity()));
         else
-            m_caretBase->updateCaretRect(createVisiblePosition(selection().start(), selection().affinity()));
+            m_frameCaret->updateCaretRect(createVisiblePosition(selection().start(), selection().affinity()));
     }
-    return m_caretBase->absoluteBoundsForLocalRect(selection().start().anchorNode(), m_caretBase->localCaretRectWithoutUpdate());
+    return m_frameCaret->absoluteBoundsForLocalRect(selection().start().anchorNode(), m_frameCaret->localCaretRectWithoutUpdate());
 }
 
-void FrameSelection::invalidateCaretRect()
+// TODO(yoiciho): We should move this function to FrameCaret.cpp
+void FrameCaret::invalidateCaretRect(const VisibleSelection& selection)
 {
     if (!m_caretRectDirty)
         return;
     m_caretRectDirty = false;
 
-    DCHECK(selection().isValidFor(*m_frame->document()));
+    DCHECK(selection.isValidFor(*m_frame->document()));
     LayoutObject* layoutObject = nullptr;
     LayoutRect newRect;
-    if (selection().isCaret())
-        newRect = localCaretRectOfPosition(PositionWithAffinity(selection().start(), selection().affinity()), layoutObject);
+    if (selection.isCaret())
+        newRect = localCaretRectOfPosition(PositionWithAffinity(selection.start(), selection.affinity()), layoutObject);
     Node* newNode = layoutObject ? layoutObject->node() : nullptr;
 
     if (!m_caretBlinkTimer.isActive()
         && newNode == m_previousCaretNode
         && newRect == m_previousCaretRect
-        && m_caretBase->getCaretVisibility() == m_previousCaretVisibility)
+        && getCaretVisibility() == m_previousCaretVisibility)
         return;
 
     LayoutViewItem view = m_frame->document()->layoutViewItem();
-    if (m_previousCaretNode && (m_caretBase->shouldRepaintCaret(*m_previousCaretNode) || m_caretBase->shouldRepaintCaret(view)))
-        m_caretBase->invalidateLocalCaretRect(m_previousCaretNode.get(), m_previousCaretRect);
-    if (newNode && (m_caretBase->shouldRepaintCaret(*newNode) || m_caretBase->shouldRepaintCaret(view)))
-        m_caretBase->invalidateLocalCaretRect(newNode, newRect);
+    if (m_previousCaretNode && (shouldRepaintCaret(*m_previousCaretNode) || shouldRepaintCaret(view)))
+        invalidateLocalCaretRect(m_previousCaretNode.get(), m_previousCaretRect);
+    if (newNode && (shouldRepaintCaret(*newNode) || shouldRepaintCaret(view)))
+        invalidateLocalCaretRect(newNode, newRect);
     m_previousCaretNode = newNode;
     m_previousCaretRect = newRect;
-    m_previousCaretVisibility = m_caretBase->getCaretVisibility();
+    m_previousCaretVisibility = getCaretVisibility();
+}
+
+void FrameSelection::invalidateCaretRect()
+{
+    m_frameCaret->invalidateCaretRect(selection());
+}
+
+// TODO(yoiciho): We should move this function to FrameCaret.cpp
+void FrameCaret::dataWillChange(const CharacterData& node)
+{
+    if (node == m_previousCaretNode) {
+        // This invalidation is eager, and intentionally uses stale state.
+        DisableCompositingQueryAsserts disabler;
+        invalidateLocalCaretRect(m_previousCaretNode.get(), m_previousCaretRect);
+    }
 }
 
 void FrameSelection::dataWillChange(const CharacterData& node)
 {
-    if (node == m_previousCaretNode) {
-        // This invalidation is eager, and intentionally uses stale state.
-        DisableCompositingQueryAsserts disabler;
-        m_caretBase->invalidateLocalCaretRect(m_previousCaretNode.get(), m_previousCaretRect);
+    m_frameCaret->dataWillChange(node);
+}
+
+// TODO(yoiciho): We should move this function to FrameCaret.cpp
+void FrameCaret::paintCaret(GraphicsContext& context, const LayoutPoint& paintOffset, const VisibleSelection& selection)
+{
+    if (selection.isCaret() && m_shouldPaintCaret) {
+        updateCaretRect(PositionWithAffinity(selection.start(), selection.affinity()));
+        CaretBase::paintCaret(selection.start().anchorNode(), context, paintOffset);
     }
 }
 
 void FrameSelection::paintCaret(GraphicsContext& context, const LayoutPoint& paintOffset)
 {
-    if (selection().isCaret() && m_shouldPaintCaret) {
-        m_caretBase->updateCaretRect(PositionWithAffinity(selection().start(), selection().affinity()));
-        m_caretBase->paintCaret(selection().start().anchorNode(), context, paintOffset);
-    }
+    m_frameCaret->paintCaret(context, paintOffset, selection());
 }
 
 bool FrameSelection::contains(const LayoutPoint& point)
 {
     Document* document = m_frame->document();
     if (document->layoutViewItem().isNull())
         return false;
 
     // Treat a collapsed selection like no selection.
     const VisibleSelectionInFlatTree& visibleSelection = this->visibleSelection<EditingInFlatTreeStrategy>();
@@ skipping 253 matching lines @@
 bool FrameSelection::isAppearanceDirty() const
 {
     return m_pendingSelection->hasPendingSelection();
 }
 
 void FrameSelection::commitAppearanceIfNeeded(LayoutView& layoutView)
 {
     return m_pendingSelection->commit(layoutView);
 }
 
+// TODO(yoiciho): We should move this function to FrameCaret.cpp
+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();
+
+}
+
+// TODO(yoichio): All of functionality should be in FrameCaret.
+// FrameCaret should have PositionWithAffnity and FrameSelection set in
+// setSelecitonAlgorithm.
 void FrameSelection::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 && selection().isCaret() && !isLogicalEndOfLine(selection().visibleEnd());
 
     bool shouldBlink = !paintBlockCursor && shouldBlinkCaret();
 
     // If the caret moved, stop the blink timer so we can restart with a
     // black caret in the new location.
     if (!shouldBlink || shouldStopBlinkingDueToTypingCommand(m_frame))
-        stopCaretBlinkTimer();
+        m_frameCaret->stopCaretBlinkTimer();
 
     // Start blinking with a black caret. Be sure not to restart if we're
     // already blinking in the right location.
-    if (shouldBlink && !m_caretBlinkTimer.isActive()) {
-        if (double blinkInterval = LayoutTheme::theme().caretBlinkInterval())
-            m_caretBlinkTimer.startRepeating(blinkInterval, BLINK_FROM_HERE);
-
-        m_shouldPaintCaret = true;
-        setCaretRectNeedsUpdate();
-    }
+    if (shouldBlink)
+        m_frameCaret->startBlinkCaret();
 
     if (m_frame->contentLayoutItem().isNull())
         return;
     m_pendingSelection->setHasPendingSelection();
 }
 
+// TODO(yoichio): All of functionality should be in FrameCaret.
+// FrameCaret should have PositionWithAffnity and FrameSelection set in
+// setSelecitonAlgorithm.
 void FrameSelection::setCaretVisibility(CaretVisibility visibility)
 {
-    if (m_caretBase->getCaretVisibility() == visibility)
+    if (m_frameCaret->getCaretVisibility() == visibility)
         return;
 
-    m_caretBase->setCaretVisibility(visibility);
+    m_frameCaret->setCaretVisibility(visibility);
 
     updateAppearance();
 }
 
 bool FrameSelection::shouldBlinkCaret() const
 {
-    if (!m_caretBase->caretIsVisible() || !isCaret())
+    if (!m_frameCaret->caretIsVisible() || !isCaret())
         return false;
 
     if (m_frame->settings() && m_frame->settings()->caretBrowsingEnabled())
         return false;
 
     Element* root = rootEditableElement();
     if (!root)
         return false;
 
     Element* focusedElement = root->document().focusedElement();
     if (!focusedElement)
         return false;
 
     return focusedElement->isShadowIncludingInclusiveAncestorOf(selection().start().anchorNode());
 }
 
-void FrameSelection::caretBlinkTimerFired(Timer<FrameSelection>*)
+// TODO(yoiciho): We should move this function to FrameCaret.cpp
+void FrameCaret::caretBlinkTimerFired(Timer<FrameCaret>*)
 {
-    DCHECK(m_caretBase->caretIsVisible());
-    DCHECK(isCaret());
+    DCHECK(caretIsVisible());
     if (isCaretBlinkingSuspended() && m_shouldPaintCaret)
         return;
     m_shouldPaintCaret = !m_shouldPaintCaret;
     setCaretRectNeedsUpdate();
 }
 
-void FrameSelection::stopCaretBlinkTimer()
+// TODO(yoiciho): We should move this function to FrameCaret.cpp
+void FrameCaret::stopCaretBlinkTimer()
 {
     if (m_caretBlinkTimer.isActive() || m_shouldPaintCaret)
         setCaretRectNeedsUpdate();
     m_shouldPaintCaret = false;
     m_caretBlinkTimer.stop();
 }
 
 void FrameSelection::notifyLayoutObjectOfSelectionChange(EUserTriggered userTriggered)
 {
     if (HTMLTextFormControlElement* textControl = enclosingTextFormControl(start()))
@@ skipping 230 matching lines @@
 
 #endif
 
 DEFINE_TRACE(FrameSelection)
 {
     visitor->trace(m_frame);
     visitor->trace(m_pendingSelection);
     visitor->trace(m_selectionEditor);
     visitor->trace(m_originalBase);
     visitor->trace(m_originalBaseInFlatTree);
-    visitor->trace(m_previousCaretNode);
     visitor->trace(m_typingStyle);
+    visitor->trace(m_frameCaret);
 }
 
-void FrameSelection::setCaretRectNeedsUpdate()
+// TODO(yoiciho): We should move this function to FrameCaret.cpp
+void FrameCaret::setCaretRectNeedsUpdate()
 {
     if (m_caretRectDirty)
         return;
     m_caretRectDirty = true;
 
-    scheduleVisualUpdate();
+    if (!m_frame)

[yosin_UTC9, 2016/05/20 07:53:13]

Since |m_frame| can't be null, we don't need to check.

[yoichio, 2016/05/20 08:58:09]

Done.

+        return;
+    if (Page* page = m_frame->page())
+        page->animator().scheduleVisualUpdate(m_frame->localFrameRoot());
 }
 
 void FrameSelection::scheduleVisualUpdate() const
 {
     if (!m_frame)
         return;
     if (Page* page = m_frame->page())
         page->animator().scheduleVisualUpdate(m_frame->localFrameRoot());
 }
 
@@ skipping 60 matching lines @@
 void FrameSelection::updateIfNeeded()
 {
     m_selectionEditor->updateIfNeeded();
 }
 
 void FrameSelection::setCaretVisible(bool caretIsVisible)
 {
     setCaretVisibility(caretIsVisible ? CaretVisibility::Visible : CaretVisibility::Hidden);
 }
 
+bool FrameSelection::shouldPaintCaretForTesting() const
+{
+    return m_frameCaret->shouldPaintCaretForTesting();
+}
+
+bool FrameSelection::isPreviousCaretDirtyForTesting() const
+{
+    return m_frameCaret->isPreviousCaretDirtyForTesting();
+}
+
+bool FrameSelection::isCaretBoundsDirty() const
+{
+    return m_frameCaret->isCaretBoundsDirty();
+}
+
+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
         fprintf(stderr, "Cannot showTree for (nil) FrameSelection.\n");
 }
 
 #endif