src/third_party/WebKit/Source/core/editing/FrameSelection.cpp

   1 /*
   2  * Copyright (C) 2004, 2008, 2009, 2010 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "core/editing/FrameSelection.h"
  28
  29 #include <stdio.h>
  30 #include "bindings/v8/ExceptionState.h"
  31 #include "core/HTMLNames.h"
  32 #include "core/accessibility/AXObjectCache.h"
  33 #include "core/css/StylePropertySet.h"
  34 #include "core/dom/CharacterData.h"
  35 #include "core/dom/Document.h"
  36 #include "core/dom/Element.h"
  37 #include "core/dom/ElementTraversal.h"
  38 #include "core/dom/NodeTraversal.h"
  39 #include "core/dom/Text.h"
  40 #include "core/editing/Editor.h"
  41 #include "core/editing/InputMethodController.h"
  42 #include "core/editing/RenderedPosition.h"
  43 #include "core/editing/SpellChecker.h"
  44 #include "core/editing/TextIterator.h"
  45 #include "core/editing/TypingCommand.h"
  46 #include "core/editing/VisibleUnits.h"
  47 #include "core/editing/htmlediting.h"
  48 #include "core/frame/LocalDOMWindow.h"
  49 #include "core/frame/LocalFrame.h"
  50 #include "core/html/HTMLBodyElement.h"
  51 #include "core/html/HTMLFormElement.h"
  52 #include "core/html/HTMLFrameElementBase.h"
  53 #include "core/html/HTMLInputElement.h"
  54 #include "core/html/HTMLSelectElement.h"
  55 #include "core/page/EditorClient.h"
  56 #include "core/page/EventHandler.h"
  57 #include "core/page/FocusController.h"
  58 #include "core/page/FrameTree.h"
  59 #include "core/frame/FrameView.h"
  60 #include "core/page/Page.h"
  61 #include "core/frame/Settings.h"
  62 #include "core/page/SpatialNavigation.h"
  63 #include "core/rendering/HitTestRequest.h"
  64 #include "core/rendering/HitTestResult.h"
  65 #include "core/rendering/InlineTextBox.h"
  66 #include "core/rendering/RenderLayer.h"
  67 #include "core/rendering/RenderText.h"
  68 #include "core/rendering/RenderTheme.h"
  69 #include "core/rendering/RenderView.h"
  70 #include "core/rendering/RenderWidget.h"
  71 #include "platform/SecureTextInput.h"
  72 #include "platform/geometry/FloatQuad.h"
  73 #include "platform/graphics/GraphicsContext.h"
  74 #include "wtf/text/CString.h"
  75
  76 #define EDIT_DEBUG 0
  77
  78 namespace WebCore {
  79
  80 using namespace HTMLNames;
  81
  82 static inline LayoutUnit NoXPosForVerticalArrowNavigation()
  83 {
  84     return LayoutUnit::min();
  85 }
  86
  87 static inline bool shouldAlwaysUseDirectionalSelection(LocalFrame* frame)
  88 {
  89     return !frame || frame->editor().behavior().shouldConsiderSelectionAsDirectional();
  90 }
  91
  92 FrameSelection::FrameSelection(LocalFrame* frame)
  93     : m_frame(frame)
  94     , m_xPosForVerticalArrowNavigation(NoXPosForVerticalArrowNavigation())
  95     , m_observingVisibleSelection(false)
  96     , m_granularity(CharacterGranularity)
  97     , m_caretBlinkTimer(this, &FrameSelection::caretBlinkTimerFired)
  98     , m_absCaretBoundsDirty(true)
  99     , m_caretPaint(true)
 100     , m_isCaretBlinkingSuspended(false)
 101     , m_focused(frame && frame->page() && frame->page()->focusController().focusedFrame() == frame)
 102     , m_shouldShowBlockCursor(false)
 103 {
 104     if (shouldAlwaysUseDirectionalSelection(m_frame))
 105         m_selection.setIsDirectional(true);
 106 }
 107
 108 FrameSelection::~FrameSelection()
 109 {
 110 #if !ENABLE(OILPAN)
 111     // Oilpan: No need to clear out VisibleSelection observer;
 112     // it is finalized as a part object of FrameSelection.
 113     stopObservingVisibleSelectionChangeIfNecessary();
 114 #endif
 115 }
 116
 117 Element* FrameSelection::rootEditableElementOrDocumentElement() const
 118 {
 119     Element* selectionRoot = m_selection.rootEditableElement();
 120     return selectionRoot ? selectionRoot : m_frame->document()->documentElement();
 121 }
 122
 123 Node* FrameSelection::rootEditableElementOrTreeScopeRootNode() const
 124 {
 125     Element* selectionRoot = m_selection.rootEditableElement();
 126     if (selectionRoot)
 127         return selectionRoot;
 128
 129     Node* node = m_selection.base().containerNode();
 130     return node ? &node->treeScope().rootNode() : 0;
 131 }
 132
 133 void FrameSelection::moveTo(const VisiblePosition &pos, EUserTriggered userTriggered, CursorAlignOnScroll align)
 134 {
 135     SetSelectionOptions options = CloseTyping | ClearTypingStyle | userTriggered;
 136     setSelection(VisibleSelection(pos.deepEquivalent(), pos.deepEquivalent(), pos.affinity(), m_selection.isDirectional()), options, align);
 137 }
 138
 139 void FrameSelection::moveTo(const VisiblePosition &base, const VisiblePosition &extent, EUserTriggered userTriggered)
 140 {
 141     const bool selectionHasDirection = true;
 142     SetSelectionOptions options = CloseTyping | ClearTypingStyle | userTriggered;
 143     setSelection(VisibleSelection(base.deepEquivalent(), extent.deepEquivalent(), base.affinity(), selectionHasDirection), options);
 144 }
 145
 146 void FrameSelection::moveTo(const Position &pos, EAffinity affinity, EUserTriggered userTriggered)
 147 {
 148     SetSelectionOptions options = CloseTyping | ClearTypingStyle | userTriggered;
 149     setSelection(VisibleSelection(pos, affinity, m_selection.isDirectional()), options);
 150 }
 151
 152 static void adjustEndpointsAtBidiBoundary(VisiblePosition& visibleBase, VisiblePosition& visibleExtent)
 153 {
 154     RenderedPosition base(visibleBase);
 155     RenderedPosition extent(visibleExtent);
 156
 157     if (base.isNull() || extent.isNull() || base.isEquivalent(extent))
 158         return;
 159
 160     if (base.atLeftBoundaryOfBidiRun()) {
 161         if (!extent.atRightBoundaryOfBidiRun(base.bidiLevelOnRight())
 162             && base.isEquivalent(extent.leftBoundaryOfBidiRun(base.bidiLevelOnRight()))) {
 163             visibleBase = VisiblePosition(base.positionAtLeftBoundaryOfBiDiRun());
 164             return;
 165         }
 166         return;
 167     }
 168
 169     if (base.atRightBoundaryOfBidiRun()) {
 170         if (!extent.atLeftBoundaryOfBidiRun(base.bidiLevelOnLeft())
 171             && base.isEquivalent(extent.rightBoundaryOfBidiRun(base.bidiLevelOnLeft()))) {
 172             visibleBase = VisiblePosition(base.positionAtRightBoundaryOfBiDiRun());
 173             return;
 174         }
 175         return;
 176     }
 177
 178     if (extent.atLeftBoundaryOfBidiRun() && extent.isEquivalent(base.leftBoundaryOfBidiRun(extent.bidiLevelOnRight()))) {
 179         visibleExtent = VisiblePosition(extent.positionAtLeftBoundaryOfBiDiRun());
 180         return;
 181     }
 182
 183     if (extent.atRightBoundaryOfBidiRun() && extent.isEquivalent(base.rightBoundaryOfBidiRun(extent.bidiLevelOnLeft()))) {
 184         visibleExtent = VisiblePosition(extent.positionAtRightBoundaryOfBiDiRun());
 185         return;
 186     }
 187 }
 188
 189 void FrameSelection::setNonDirectionalSelectionIfNeeded(const VisibleSelection& passedNewSelection, TextGranularity granularity,
 190     EndPointsAdjustmentMode endpointsAdjustmentMode)
 191 {
 192     VisibleSelection newSelection = passedNewSelection;
 193     bool isDirectional = shouldAlwaysUseDirectionalSelection(m_frame) || newSelection.isDirectional();
 194
 195     VisiblePosition base = m_originalBase.isNotNull() ? m_originalBase : newSelection.visibleBase();
 196     VisiblePosition newBase = base;
 197     VisiblePosition extent = newSelection.visibleExtent();
 198     VisiblePosition newExtent = extent;
 199     if (endpointsAdjustmentMode == AdjustEndpointsAtBidiBoundary)
 200         adjustEndpointsAtBidiBoundary(newBase, newExtent);
 201
 202     if (newBase != base || newExtent != extent) {
 203         m_originalBase = base;
 204         newSelection.setBase(newBase);
 205         newSelection.setExtent(newExtent);
 206     } else if (m_originalBase.isNotNull()) {
 207         if (m_selection.base() == newSelection.base())
 208             newSelection.setBase(m_originalBase);
 209         m_originalBase.clear();
 210     }
 211
 212     newSelection.setIsDirectional(isDirectional); // Adjusting base and extent will make newSelection always directional
 213     if (m_selection == newSelection)
 214         return;
 215
 216     setSelection(newSelection, granularity);
 217 }
 218
 219 void FrameSelection::setSelection(const VisibleSelection& newSelection, SetSelectionOptions options, CursorAlignOnScroll align, TextGranularity granularity)
 220 {
 221     bool closeTyping = options & CloseTyping;
 222     bool shouldClearTypingStyle = options & ClearTypingStyle;
 223     EUserTriggered userTriggered = selectionOptionsToUserTriggered(options);
 224
 225     VisibleSelection s = validateSelection(newSelection);
 226     if (shouldAlwaysUseDirectionalSelection(m_frame))
 227         s.setIsDirectional(true);
 228
 229     if (!m_frame) {
 230         m_selection = s;
 231         return;
 232     }
 233
 234     // <http://bugs.webkit.org/show_bug.cgi?id=23464>: Infinite recursion at FrameSelection::setSelection
 235     // if document->frame() == m_frame we can get into an infinite loop
 236     if (s.base().anchorNode()) {
 237         Document& document = *s.base().document();
 238         if (document.frame() && document.frame() != m_frame && document != m_frame->document()) {
 239             RefPtr<LocalFrame> guard = document.frame();
 240             document.frame()->selection().setSelection(s, options, align, granularity);
 241             // It's possible that during the above set selection, this FrameSelection has been modified by
 242             // selectFrameElementInParentIfFullySelected, but that the selection is no longer valid since
 243             // the frame is about to be destroyed. If this is the case, clear our selection.
 244             if (guard->hasOneRef() && !m_selection.isNonOrphanedCaretOrRange())
 245                 clear();
 246             return;
 247         }
 248     }
 249
 250     m_granularity = granularity;
 251
 252     if (closeTyping)
 253         TypingCommand::closeTyping(m_frame);
 254
 255     if (shouldClearTypingStyle)
 256         clearTypingStyle();
 257
 258     if (m_selection == s) {
 259         // Even if selection was not changed, selection offsets may have been changed.
 260         m_frame->inputMethodController().cancelCompositionIfSelectionIsInvalid();
 261         notifyRendererOfSelectionChange(userTriggered);
 262         return;
 263     }
 264
 265     VisibleSelection oldSelection = m_selection;
 266
 267     m_selection = s;
 268     setCaretRectNeedsUpdate();
 269
 270     if (!s.isNone() && !(options & DoNotSetFocus))
 271         setFocusedNodeIfNeeded();
 272
 273     if (!(options & DoNotUpdateAppearance)) {
 274         m_frame->document()->updateLayoutIgnorePendingStylesheets();
 275
 276         // Hits in compositing/overflow/do-not-paint-outline-into-composited-scrolling-contents.html
 277         DisableCompositingQueryAsserts disabler;
 278         updateAppearance();
 279     }
 280
 281     // Always clear the x position used for vertical arrow navigation.
 282     // It will be restored by the vertical arrow navigation code if necessary.
 283     m_xPosForVerticalArrowNavigation = NoXPosForVerticalArrowNavigation();
 284     selectFrameElementInParentIfFullySelected();
 285     notifyRendererOfSelectionChange(userTriggered);
 286     m_frame->editor().respondToChangedSelection(oldSelection, options);
 287     if (userTriggered == UserTriggered) {
 288         ScrollAlignment alignment;
 289
 290         if (m_frame->editor().behavior().shouldCenterAlignWhenSelectionIsRevealed())
 291             alignment = (align == AlignCursorOnScrollAlways) ? ScrollAlignment::alignCenterAlways : ScrollAlignment::alignCenterIfNeeded;
 292         else
 293             alignment = (align == AlignCursorOnScrollAlways) ? ScrollAlignment::alignTopAlways : ScrollAlignment::alignToEdgeIfNeeded;
 294
 295         revealSelection(alignment, RevealExtent);
 296     }
 297
 298     notifyAccessibilityForSelectionChange();
 299     m_frame->domWindow()->enqueueDocumentEvent(Event::create(EventTypeNames::selectionchange));
 300 }
 301
 302 static bool removingNodeRemovesPosition(Node& node, const Position& position)
 303 {
 304     if (!position.anchorNode())
 305         return false;
 306
 307     if (position.anchorNode() == node)
 308         return true;
 309
 310     if (!node.isElementNode())
 311         return false;
 312
 313     Element& element = toElement(node);
 314     return element.containsIncludingShadowDOM(position.anchorNode());
 315 }
 316
 317 void FrameSelection::nodeWillBeRemoved(Node& node)
 318 {
 319     // There can't be a selection inside a fragment, so if a fragment's node is being removed,
 320     // the selection in the document that created the fragment needs no adjustment.
 321     if (isNone() || !node.inActiveDocument())
 322         return;
 323
 324     respondToNodeModification(node, removingNodeRemovesPosition(node, m_selection.base()), removingNodeRemovesPosition(node, m_selection.extent()),
 325         removingNodeRemovesPosition(node, m_selection.start()), removingNodeRemovesPosition(node, m_selection.end()));
 326 }
 327
 328 void FrameSelection::respondToNodeModification(Node& node, bool baseRemoved, bool extentRemoved, bool startRemoved, bool endRemoved)
 329 {
 330     ASSERT(node.document().isActive());
 331
 332     bool clearRenderTreeSelection = false;
 333     bool clearDOMTreeSelection = false;
 334
 335     if (startRemoved || endRemoved) {
 336         Position start = m_selection.start();
 337         Position end = m_selection.end();
 338         if (startRemoved)
 339             updatePositionForNodeRemoval(start, node);
 340         if (endRemoved)
 341             updatePositionForNodeRemoval(end, node);
 342
 343         if (start.isNotNull() && end.isNotNull()) {
 344             if (m_selection.isBaseFirst())
 345                 m_selection.setWithoutValidation(start, end);
 346             else
 347                 m_selection.setWithoutValidation(end, start);
 348         } else
 349             clearDOMTreeSelection = true;
 350
 351         clearRenderTreeSelection = true;
 352     } else if (baseRemoved || extentRemoved) {
 353         // The base and/or extent are about to be removed, but the start and end aren't.
 354         // Change the base and extent to the start and end, but don't re-validate the
 355         // selection, since doing so could move the start and end into the node
 356         // that is about to be removed.
 357         if (m_selection.isBaseFirst())
 358             m_selection.setWithoutValidation(m_selection.start(), m_selection.end());
 359         else
 360             m_selection.setWithoutValidation(m_selection.end(), m_selection.start());
 361     } else if (RefPtrWillBeRawPtr<Range> range = m_selection.firstRange()) {
 362         TrackExceptionState exceptionState;
 363         Range::CompareResults compareResult = range->compareNode(&node, exceptionState);
 364         if (!exceptionState.hadException() && (compareResult == Range::NODE_BEFORE_AND_AFTER || compareResult == Range::NODE_INSIDE)) {
 365             // If we did nothing here, when this node's renderer was destroyed, the rect that it
 366             // occupied would be invalidated, but, selection gaps that change as a result of
 367             // the removal wouldn't be invalidated.
 368             // FIXME: Don't do so much unnecessary invalidation.
 369             clearRenderTreeSelection = true;
 370         }
 371     }
 372
 373     if (clearRenderTreeSelection)
 374         m_selection.start().document()->renderView()->clearSelection();
 375
 376     if (clearDOMTreeSelection)
 377         setSelection(VisibleSelection(), DoNotSetFocus);
 378 }
 379
 380 static Position updatePositionAfterAdoptingTextReplacement(const Position& position, CharacterData* node, unsigned offset, unsigned oldLength, unsigned newLength)
 381 {
 382     if (!position.anchorNode() || position.anchorNode() != node || position.anchorType() != Position::PositionIsOffsetInAnchor)
 383         return position;
 384
 385     // See: http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Mutation
 386     ASSERT(position.offsetInContainerNode() >= 0);
 387     unsigned positionOffset = static_cast<unsigned>(position.offsetInContainerNode());
 388     // Replacing text can be viewed as a deletion followed by insertion.
 389     if (positionOffset >= offset && positionOffset <= offset + oldLength)
 390         positionOffset = offset;
 391
 392     // Adjust the offset if the position is after the end of the deleted contents
 393     // (positionOffset > offset + oldLength) to avoid having a stale offset.
 394     if (positionOffset > offset + oldLength)
 395         positionOffset = positionOffset - oldLength + newLength;
 396
 397     ASSERT_WITH_SECURITY_IMPLICATION(positionOffset <= node->length());
 398     // CharacterNode in VisibleSelection must be Text node, because Comment
 399     // and ProcessingInstruction node aren't visible.
 400     return Position(toText(node), positionOffset);
 401 }
 402
 403 void FrameSelection::didUpdateCharacterData(CharacterData* node, unsigned offset, unsigned oldLength, unsigned newLength)
 404 {
 405     // The fragment check is a performance optimization. See http://trac.webkit.org/changeset/30062.
 406     if (isNone() || !node || !node->inDocument())
 407         return;
 408
 409     Position base = updatePositionAfterAdoptingTextReplacement(m_selection.base(), node, offset, oldLength, newLength);
 410     Position extent = updatePositionAfterAdoptingTextReplacement(m_selection.extent(), node, offset, oldLength, newLength);
 411     Position start = updatePositionAfterAdoptingTextReplacement(m_selection.start(), node, offset, oldLength, newLength);
 412     Position end = updatePositionAfterAdoptingTextReplacement(m_selection.end(), node, offset, oldLength, newLength);
 413     updateSelectionIfNeeded(base, extent, start, end);
 414 }
 415
 416 static Position updatePostionAfterAdoptingTextNodesMerged(const Position& position, const Text& oldNode, unsigned offset)
 417 {
 418     if (!position.anchorNode() || position.anchorType() != Position::PositionIsOffsetInAnchor)
 419         return position;
 420
 421     ASSERT(position.offsetInContainerNode() >= 0);
 422     unsigned positionOffset = static_cast<unsigned>(position.offsetInContainerNode());
 423
 424     if (position.anchorNode() == &oldNode)
 425         return Position(toText(oldNode.previousSibling()), positionOffset + offset);
 426
 427     if (position.anchorNode() == oldNode.parentNode() && positionOffset == offset)
 428         return Position(toText(oldNode.previousSibling()), offset);
 429
 430     return position;
 431 }
 432
 433 void FrameSelection::didMergeTextNodes(const Text& oldNode, unsigned offset)
 434 {
 435     if (isNone() || !oldNode.inDocument())
 436         return;
 437     Position base = updatePostionAfterAdoptingTextNodesMerged(m_selection.base(), oldNode, offset);
 438     Position extent = updatePostionAfterAdoptingTextNodesMerged(m_selection.extent(), oldNode, offset);
 439     Position start = updatePostionAfterAdoptingTextNodesMerged(m_selection.start(), oldNode, offset);
 440     Position end = updatePostionAfterAdoptingTextNodesMerged(m_selection.end(), oldNode, offset);
 441     updateSelectionIfNeeded(base, extent, start, end);
 442 }
 443
 444 static Position updatePostionAfterAdoptingTextNodeSplit(const Position& position, const Text& oldNode)
 445 {
 446     if (!position.anchorNode() || position.anchorNode() != &oldNode || position.anchorType() != Position::PositionIsOffsetInAnchor)
 447         return position;
 448     // See: http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Mutation
 449     ASSERT(position.offsetInContainerNode() >= 0);
 450     unsigned positionOffset = static_cast<unsigned>(position.offsetInContainerNode());
 451     unsigned oldLength = oldNode.length();
 452     if (positionOffset <= oldLength)
 453         return position;
 454     return Position(toText(oldNode.nextSibling()), positionOffset - oldLength);
 455 }
 456
 457 void FrameSelection::didSplitTextNode(const Text& oldNode)
 458 {
 459     if (isNone() || !oldNode.inDocument())
 460         return;
 461     Position base = updatePostionAfterAdoptingTextNodeSplit(m_selection.base(), oldNode);
 462     Position extent = updatePostionAfterAdoptingTextNodeSplit(m_selection.extent(), oldNode);
 463     Position start = updatePostionAfterAdoptingTextNodeSplit(m_selection.start(), oldNode);
 464     Position end = updatePostionAfterAdoptingTextNodeSplit(m_selection.end(), oldNode);
 465     updateSelectionIfNeeded(base, extent, start, end);
 466 }
 467
 468 void FrameSelection::updateSelectionIfNeeded(const Position& base, const Position& extent, const Position& start, const Position& end)
 469 {
 470     if (base == m_selection.base() && extent == m_selection.extent() && start == m_selection.start() && end == m_selection.end())
 471         return;
 472     VisibleSelection newSelection;
 473     newSelection.setWithoutValidation(base, extent);
 474     setSelection(newSelection, DoNotSetFocus);
 475 }
 476
 477 TextDirection FrameSelection::directionOfEnclosingBlock()
 478 {
 479     return WebCore::directionOfEnclosingBlock(m_selection.extent());
 480 }
 481
 482 TextDirection FrameSelection::directionOfSelection()
 483 {
 484     InlineBox* startBox = 0;
 485     InlineBox* endBox = 0;
 486     int unusedOffset;
 487     // Cache the VisiblePositions because visibleStart() and visibleEnd()
 488     // can cause layout, which has the potential to invalidate lineboxes.
 489     VisiblePosition startPosition = m_selection.visibleStart();
 490     VisiblePosition endPosition = m_selection.visibleEnd();
 491     if (startPosition.isNotNull())
 492         startPosition.getInlineBoxAndOffset(startBox, unusedOffset);
 493     if (endPosition.isNotNull())
 494         endPosition.getInlineBoxAndOffset(endBox, unusedOffset);
 495     if (startBox && endBox && startBox->direction() == endBox->direction())
 496         return startBox->direction();
 497
 498     return directionOfEnclosingBlock();
 499 }
 500
 501 void FrameSelection::didChangeFocus()
 502 {
 503     // Hits in virtual/gpu/compositedscrolling/scrollbars/scrollbar-miss-mousemove-disabled.html
 504     DisableCompositingQueryAsserts disabler;
 505     updateAppearance();
 506 }
 507
 508 void FrameSelection::willBeModified(EAlteration alter, SelectionDirection direction)
 509 {
 510     if (alter != AlterationExtend)
 511         return;
 512
 513     Position start = m_selection.start();
 514     Position end = m_selection.end();
 515
 516     bool baseIsStart = true;
 517
 518     if (m_selection.isDirectional()) {
 519         // Make base and extent match start and end so we extend the user-visible selection.
 520         // This only matters for cases where base and extend point to different positions than
 521         // start and end (e.g. after a double-click to select a word).
 522         if (m_selection.isBaseFirst())
 523             baseIsStart = true;
 524         else
 525             baseIsStart = false;
 526     } else {
 527         switch (direction) {
 528         case DirectionRight:
 529             if (directionOfSelection() == LTR)
 530                 baseIsStart = true;
 531             else
 532                 baseIsStart = false;
 533             break;
 534         case DirectionForward:
 535             baseIsStart = true;
 536             break;
 537         case DirectionLeft:
 538             if (directionOfSelection() == LTR)
 539                 baseIsStart = false;
 540             else
 541                 baseIsStart = true;
 542             break;
 543         case DirectionBackward:
 544             baseIsStart = false;
 545             break;
 546         }
 547     }
 548     if (baseIsStart) {
 549         m_selection.setBase(start);
 550         m_selection.setExtent(end);
 551     } else {
 552         m_selection.setBase(end);
 553         m_selection.setExtent(start);
 554     }
 555 }
 556
 557 VisiblePosition FrameSelection::positionForPlatform(bool isGetStart) const
 558 {
 559     Settings* settings = m_frame ? m_frame->settings() : 0;
 560     if (settings && settings->editingBehaviorType() == EditingMacBehavior)
 561         return isGetStart ? m_selection.visibleStart() : m_selection.visibleEnd();
 562     // Linux and Windows always extend selections from the extent endpoint.
 563     // FIXME: VisibleSelection should be fixed to ensure as an invariant that
 564     // base/extent always point to the same nodes as start/end, but which points
 565     // to which depends on the value of isBaseFirst. Then this can be changed
 566     // to just return m_sel.extent().
 567     return m_selection.isBaseFirst() ? m_selection.visibleEnd() : m_selection.visibleStart();
 568 }
 569
 570 VisiblePosition FrameSelection::startForPlatform() const
 571 {
 572     return positionForPlatform(true);
 573 }
 574
 575 VisiblePosition FrameSelection::endForPlatform() const
 576 {
 577     return positionForPlatform(false);
 578 }
 579
 580 VisiblePosition FrameSelection::nextWordPositionForPlatform(const VisiblePosition &originalPosition)
 581 {
 582     VisiblePosition positionAfterCurrentWord = nextWordPosition(originalPosition);
 583
 584     if (m_frame && m_frame->editor().behavior().shouldSkipSpaceWhenMovingRight()) {
 585         // In order to skip spaces when moving right, we advance one
 586         // word further and then move one word back. Given the
 587         // semantics of previousWordPosition() this will put us at the
 588         // beginning of the word following.
 589         VisiblePosition positionAfterSpacingAndFollowingWord = nextWordPosition(positionAfterCurrentWord);
 590         if (positionAfterSpacingAndFollowingWord.isNotNull() && positionAfterSpacingAndFollowingWord != positionAfterCurrentWord)
 591             positionAfterCurrentWord = previousWordPosition(positionAfterSpacingAndFollowingWord);
 592
 593         bool movingBackwardsMovedPositionToStartOfCurrentWord = positionAfterCurrentWord == previousWordPosition(nextWordPosition(originalPosition));
 594         if (movingBackwardsMovedPositionToStartOfCurrentWord)
 595             positionAfterCurrentWord = positionAfterSpacingAndFollowingWord;
 596     }
 597     return positionAfterCurrentWord;
 598 }
 599
 600 static void adjustPositionForUserSelectAll(VisiblePosition& pos, bool isForward)
 601 {
 602     if (Node* rootUserSelectAll = Position::rootUserSelectAllForNode(pos.deepEquivalent().anchorNode()))
 603         pos = VisiblePosition(isForward ? positionAfterNode(rootUserSelectAll).downstream(CanCrossEditingBoundary) : positionBeforeNode(rootUserSelectAll).upstream(CanCrossEditingBoundary));
 604 }
 605
 606 VisiblePosition FrameSelection::modifyExtendingRight(TextGranularity granularity)
 607 {
 608     VisiblePosition pos(m_selection.extent(), m_selection.affinity());
 609
 610     // The difference between modifyExtendingRight and modifyExtendingForward is:
 611     // modifyExtendingForward always extends forward logically.
 612     // modifyExtendingRight behaves the same as modifyExtendingForward except for extending character or word,
 613     // it extends forward logically if the enclosing block is LTR direction,
 614     // but it extends backward logically if the enclosing block is RTL direction.
 615     switch (granularity) {
 616     case CharacterGranularity:
 617         if (directionOfEnclosingBlock() == LTR)
 618             pos = pos.next(CanSkipOverEditingBoundary);
 619         else
 620             pos = pos.previous(CanSkipOverEditingBoundary);
 621         break;
 622     case WordGranularity:
 623         if (directionOfEnclosingBlock() == LTR)
 624             pos = nextWordPositionForPlatform(pos);
 625         else
 626             pos = previousWordPosition(pos);
 627         break;
 628     case LineBoundary:
 629         if (directionOfEnclosingBlock() == LTR)
 630             pos = modifyExtendingForward(granularity);
 631         else
 632             pos = modifyExtendingBackward(granularity);
 633         break;
 634     case SentenceGranularity:
 635     case LineGranularity:
 636     case ParagraphGranularity:
 637     case SentenceBoundary:
 638     case ParagraphBoundary:
 639     case DocumentBoundary:
 640         // FIXME: implement all of the above?
 641         pos = modifyExtendingForward(granularity);
 642         break;
 643     }
 644     adjustPositionForUserSelectAll(pos, directionOfEnclosingBlock() == LTR);
 645     return pos;
 646 }
 647
 648 VisiblePosition FrameSelection::modifyExtendingForward(TextGranularity granularity)
 649 {
 650     VisiblePosition pos(m_selection.extent(), m_selection.affinity());
 651     switch (granularity) {
 652     case CharacterGranularity:
 653         pos = pos.next(CanSkipOverEditingBoundary);
 654         break;
 655     case WordGranularity:
 656         pos = nextWordPositionForPlatform(pos);
 657         break;
 658     case SentenceGranularity:
 659         pos = nextSentencePosition(pos);
 660         break;
 661     case LineGranularity:
 662         pos = nextLinePosition(pos, lineDirectionPointForBlockDirectionNavigation(EXTENT));
 663         break;
 664     case ParagraphGranularity:
 665         pos = nextParagraphPosition(pos, lineDirectionPointForBlockDirectionNavigation(EXTENT));
 666         break;
 667     case SentenceBoundary:
 668         pos = endOfSentence(endForPlatform());
 669         break;
 670     case LineBoundary:
 671         pos = logicalEndOfLine(endForPlatform());
 672         break;
 673     case ParagraphBoundary:
 674         pos = endOfParagraph(endForPlatform());
 675         break;
 676     case DocumentBoundary:
 677         pos = endForPlatform();
 678         if (isEditablePosition(pos.deepEquivalent()))
 679             pos = endOfEditableContent(pos);
 680         else
 681             pos = endOfDocument(pos);
 682         break;
 683     }
 684     adjustPositionForUserSelectAll(pos, directionOfEnclosingBlock() == LTR);
 685     return pos;
 686 }
 687
 688 VisiblePosition FrameSelection::modifyMovingRight(TextGranularity granularity)
 689 {
 690     VisiblePosition pos;
 691     switch (granularity) {
 692     case CharacterGranularity:
 693         if (isRange()) {
 694             if (directionOfSelection() == LTR)
 695                 pos = VisiblePosition(m_selection.end(), m_selection.affinity());
 696             else
 697                 pos = VisiblePosition(m_selection.start(), m_selection.affinity());
 698         } else
 699             pos = VisiblePosition(m_selection.extent(), m_selection.affinity()).right(true);
 700         break;
 701     case WordGranularity: {
 702         bool skipsSpaceWhenMovingRight = m_frame && m_frame->editor().behavior().shouldSkipSpaceWhenMovingRight();
 703         pos = rightWordPosition(VisiblePosition(m_selection.extent(), m_selection.affinity()), skipsSpaceWhenMovingRight);
 704         break;
 705     }
 706     case SentenceGranularity:
 707     case LineGranularity:
 708     case ParagraphGranularity:
 709     case SentenceBoundary:
 710     case ParagraphBoundary:
 711     case DocumentBoundary:
 712         // FIXME: Implement all of the above.
 713         pos = modifyMovingForward(granularity);
 714         break;
 715     case LineBoundary:
 716         pos = rightBoundaryOfLine(startForPlatform(), directionOfEnclosingBlock());
 717         break;
 718     }
 719     return pos;
 720 }
 721
 722 VisiblePosition FrameSelection::modifyMovingForward(TextGranularity granularity)
 723 {
 724     VisiblePosition pos;
 725     // FIXME: Stay in editable content for the less common granularities.
 726     switch (granularity) {
 727     case CharacterGranularity:
 728         if (isRange())
 729             pos = VisiblePosition(m_selection.end(), m_selection.affinity());
 730         else
 731             pos = VisiblePosition(m_selection.extent(), m_selection.affinity()).next(CanSkipOverEditingBoundary);
 732         break;
 733     case WordGranularity:
 734         pos = nextWordPositionForPlatform(VisiblePosition(m_selection.extent(), m_selection.affinity()));
 735         break;
 736     case SentenceGranularity:
 737         pos = nextSentencePosition(VisiblePosition(m_selection.extent(), m_selection.affinity()));
 738         break;
 739     case LineGranularity: {
 740         // down-arrowing from a range selection that ends at the start of a line needs
 741         // to leave the selection at that line start (no need to call nextLinePosition!)
 742         pos = endForPlatform();
 743         if (!isRange() || !isStartOfLine(pos))
 744             pos = nextLinePosition(pos, lineDirectionPointForBlockDirectionNavigation(START));
 745         break;
 746     }
 747     case ParagraphGranularity:
 748         pos = nextParagraphPosition(endForPlatform(), lineDirectionPointForBlockDirectionNavigation(START));
 749         break;
 750     case SentenceBoundary:
 751         pos = endOfSentence(endForPlatform());
 752         break;
 753     case LineBoundary:
 754         pos = logicalEndOfLine(endForPlatform());
 755         break;
 756     case ParagraphBoundary:
 757         pos = endOfParagraph(endForPlatform());
 758         break;
 759     case DocumentBoundary:
 760         pos = endForPlatform();
 761         if (isEditablePosition(pos.deepEquivalent()))
 762             pos = endOfEditableContent(pos);
 763         else
 764             pos = endOfDocument(pos);
 765         break;
 766     }
 767     return pos;
 768 }
 769
 770 VisiblePosition FrameSelection::modifyExtendingLeft(TextGranularity granularity)
 771 {
 772     VisiblePosition pos(m_selection.extent(), m_selection.affinity());
 773
 774     // The difference between modifyExtendingLeft and modifyExtendingBackward is:
 775     // modifyExtendingBackward always extends backward logically.
 776     // modifyExtendingLeft behaves the same as modifyExtendingBackward except for extending character or word,
 777     // it extends backward logically if the enclosing block is LTR direction,
 778     // but it extends forward logically if the enclosing block is RTL direction.
 779     switch (granularity) {
 780     case CharacterGranularity:
 781         if (directionOfEnclosingBlock() == LTR)
 782             pos = pos.previous(CanSkipOverEditingBoundary);
 783         else
 784             pos = pos.next(CanSkipOverEditingBoundary);
 785         break;
 786     case WordGranularity:
 787         if (directionOfEnclosingBlock() == LTR)
 788             pos = previousWordPosition(pos);
 789         else
 790             pos = nextWordPositionForPlatform(pos);
 791         break;
 792     case LineBoundary:
 793         if (directionOfEnclosingBlock() == LTR)
 794             pos = modifyExtendingBackward(granularity);
 795         else
 796             pos = modifyExtendingForward(granularity);
 797         break;
 798     case SentenceGranularity:
 799     case LineGranularity:
 800     case ParagraphGranularity:
 801     case SentenceBoundary:
 802     case ParagraphBoundary:
 803     case DocumentBoundary:
 804         pos = modifyExtendingBackward(granularity);
 805         break;
 806     }
 807     adjustPositionForUserSelectAll(pos, !(directionOfEnclosingBlock() == LTR));
 808     return pos;
 809 }
 810
 811 VisiblePosition FrameSelection::modifyExtendingBackward(TextGranularity granularity)
 812 {
 813     VisiblePosition pos(m_selection.extent(), m_selection.affinity());
 814
 815     // Extending a selection backward by word or character from just after a table selects
 816     // the table.  This "makes sense" from the user perspective, esp. when deleting.
 817     // It was done here instead of in VisiblePosition because we want VPs to iterate
 818     // over everything.
 819     switch (granularity) {
 820     case CharacterGranularity:
 821         pos = pos.previous(CanSkipOverEditingBoundary);
 822         break;
 823     case WordGranularity:
 824         pos = previousWordPosition(pos);
 825         break;
 826     case SentenceGranularity:
 827         pos = previousSentencePosition(pos);
 828         break;
 829     case LineGranularity:
 830         pos = previousLinePosition(pos, lineDirectionPointForBlockDirectionNavigation(EXTENT));
 831         break;
 832     case ParagraphGranularity:
 833         pos = previousParagraphPosition(pos, lineDirectionPointForBlockDirectionNavigation(EXTENT));
 834         break;
 835     case SentenceBoundary:
 836         pos = startOfSentence(startForPlatform());
 837         break;
 838     case LineBoundary:
 839         pos = logicalStartOfLine(startForPlatform());
 840         break;
 841     case ParagraphBoundary:
 842         pos = startOfParagraph(startForPlatform());
 843         break;
 844     case DocumentBoundary:
 845         pos = startForPlatform();
 846         if (isEditablePosition(pos.deepEquivalent()))
 847             pos = startOfEditableContent(pos);
 848         else
 849             pos = startOfDocument(pos);
 850         break;
 851     }
 852     adjustPositionForUserSelectAll(pos, !(directionOfEnclosingBlock() == LTR));
 853     return pos;
 854 }
 855
 856 VisiblePosition FrameSelection::modifyMovingLeft(TextGranularity granularity)
 857 {
 858     VisiblePosition pos;
 859     switch (granularity) {
 860     case CharacterGranularity:
 861         if (isRange())
 862             if (directionOfSelection() == LTR)
 863                 pos = VisiblePosition(m_selection.start(), m_selection.affinity());
 864             else
 865                 pos = VisiblePosition(m_selection.end(), m_selection.affinity());
 866         else
 867             pos = VisiblePosition(m_selection.extent(), m_selection.affinity()).left(true);
 868         break;
 869     case WordGranularity: {
 870         bool skipsSpaceWhenMovingRight = m_frame && m_frame->editor().behavior().shouldSkipSpaceWhenMovingRight();
 871         pos = leftWordPosition(VisiblePosition(m_selection.extent(), m_selection.affinity()), skipsSpaceWhenMovingRight);
 872         break;
 873     }
 874     case SentenceGranularity:
 875     case LineGranularity:
 876     case ParagraphGranularity:
 877     case SentenceBoundary:
 878     case ParagraphBoundary:
 879     case DocumentBoundary:
 880         // FIXME: Implement all of the above.
 881         pos = modifyMovingBackward(granularity);
 882         break;
 883     case LineBoundary:
 884         pos = leftBoundaryOfLine(startForPlatform(), directionOfEnclosingBlock());
 885         break;
 886     }
 887     return pos;
 888 }
 889
 890 VisiblePosition FrameSelection::modifyMovingBackward(TextGranularity granularity)
 891 {
 892     VisiblePosition pos;
 893     switch (granularity) {
 894     case CharacterGranularity:
 895         if (isRange())
 896             pos = VisiblePosition(m_selection.start(), m_selection.affinity());
 897         else
 898             pos = VisiblePosition(m_selection.extent(), m_selection.affinity()).previous(CanSkipOverEditingBoundary);
 899         break;
 900     case WordGranularity:
 901         pos = previousWordPosition(VisiblePosition(m_selection.extent(), m_selection.affinity()));
 902         break;
 903     case SentenceGranularity:
 904         pos = previousSentencePosition(VisiblePosition(m_selection.extent(), m_selection.affinity()));
 905         break;
 906     case LineGranularity:
 907         pos = previousLinePosition(startForPlatform(), lineDirectionPointForBlockDirectionNavigation(START));
 908         break;
 909     case ParagraphGranularity:
 910         pos = previousParagraphPosition(startForPlatform(), lineDirectionPointForBlockDirectionNavigation(START));
 911         break;
 912     case SentenceBoundary:
 913         pos = startOfSentence(startForPlatform());
 914         break;
 915     case LineBoundary:
 916         pos = logicalStartOfLine(startForPlatform());
 917         break;
 918     case ParagraphBoundary:
 919         pos = startOfParagraph(startForPlatform());
 920         break;
 921     case DocumentBoundary:
 922         pos = startForPlatform();
 923         if (isEditablePosition(pos.deepEquivalent()))
 924             pos = startOfEditableContent(pos);
 925         else
 926             pos = startOfDocument(pos);
 927         break;
 928     }
 929     return pos;
 930 }
 931
 932 static bool isBoundary(TextGranularity granularity)
 933 {
 934     return granularity == LineBoundary || granularity == ParagraphBoundary || granularity == DocumentBoundary;
 935 }
 936
 937 bool FrameSelection::modify(EAlteration alter, SelectionDirection direction, TextGranularity granularity, EUserTriggered userTriggered)
 938 {
 939     if (userTriggered == UserTriggered) {
 940         OwnPtrWillBeRawPtr<FrameSelection> trialFrameSelection = FrameSelection::create();
 941         trialFrameSelection->setSelection(m_selection);
 942         trialFrameSelection->modify(alter, direction, granularity, NotUserTriggered);
 943
 944         if (trialFrameSelection->selection().isRange() && m_selection.isCaret() && !dispatchSelectStart())
 945             return false;
 946     }
 947
 948     willBeModified(alter, direction);
 949
 950     bool wasRange = m_selection.isRange();
 951     VisiblePosition originalStartPosition = m_selection.visibleStart();
 952     VisiblePosition position;
 953     switch (direction) {
 954     case DirectionRight:
 955         if (alter == AlterationMove)
 956             position = modifyMovingRight(granularity);
 957         else
 958             position = modifyExtendingRight(granularity);
 959         break;
 960     case DirectionForward:
 961         if (alter == AlterationExtend)
 962             position = modifyExtendingForward(granularity);
 963         else
 964             position = modifyMovingForward(granularity);
 965         break;
 966     case DirectionLeft:
 967         if (alter == AlterationMove)
 968             position = modifyMovingLeft(granularity);
 969         else
 970             position = modifyExtendingLeft(granularity);
 971         break;
 972     case DirectionBackward:
 973         if (alter == AlterationExtend)
 974             position = modifyExtendingBackward(granularity);
 975         else
 976             position = modifyMovingBackward(granularity);
 977         break;
 978     }
 979
 980     if (position.isNull())
 981         return false;
 982
 983     if (isSpatialNavigationEnabled(m_frame))
 984         if (!wasRange && alter == AlterationMove && position == originalStartPosition)
 985             return false;
 986
 987     // Some of the above operations set an xPosForVerticalArrowNavigation.
 988     // Setting a selection will clear it, so save it to possibly restore later.
 989     // Note: the START position type is arbitrary because it is unused, it would be
 990     // the requested position type if there were no xPosForVerticalArrowNavigation set.
 991     LayoutUnit x = lineDirectionPointForBlockDirectionNavigation(START);
 992     m_selection.setIsDirectional(shouldAlwaysUseDirectionalSelection(m_frame) || alter == AlterationExtend);
 993
 994     switch (alter) {
 995     case AlterationMove:
 996         moveTo(position, userTriggered);
 997         break;
 998     case AlterationExtend:
 999
1000         if (!m_selection.isCaret()
1001             && (granularity == WordGranularity || granularity == ParagraphGranularity || granularity == LineGranularity)
1002             && m_frame && !m_frame->editor().behavior().shouldExtendSelectionByWordOrLineAcrossCaret()) {
1003             // Don't let the selection go across the base position directly. Needed to match mac
1004             // behavior when, for instance, word-selecting backwards starting with the caret in
1005             // the middle of a word and then word-selecting forward, leaving the caret in the
1006             // same place where it was, instead of directly selecting to the end of the word.
1007             VisibleSelection newSelection = m_selection;
1008             newSelection.setExtent(position);
1009             if (m_selection.isBaseFirst() != newSelection.isBaseFirst())
1010                 position = m_selection.visibleBase();
1011         }
1012
1013         // Standard Mac behavior when extending to a boundary is grow the selection rather than leaving the
1014         // base in place and moving the extent. Matches NSTextView.
1015         if (!m_frame || !m_frame->editor().behavior().shouldAlwaysGrowSelectionWhenExtendingToBoundary() || m_selection.isCaret() || !isBoundary(granularity))
1016             setExtent(position, userTriggered);
1017         else {
1018             TextDirection textDirection = directionOfEnclosingBlock();
1019             if (direction == DirectionForward || (textDirection == LTR && direction == DirectionRight) || (textDirection == RTL && direction == DirectionLeft))
1020                 setEnd(position, userTriggered);
1021             else
1022                 setStart(position, userTriggered);
1023         }
1024         break;
1025     }
1026
1027     if (granularity == LineGranularity || granularity == ParagraphGranularity)
1028         m_xPosForVerticalArrowNavigation = x;
1029
1030     if (userTriggered == UserTriggered)
1031         m_granularity = CharacterGranularity;
1032
1033     setCaretRectNeedsUpdate();
1034
1035     return true;
1036 }
1037
1038 // FIXME: Maybe baseline would be better?
1039 static bool absoluteCaretY(const VisiblePosition &c, int &y)
1040 {
1041     IntRect rect = c.absoluteCaretBounds();
1042     if (rect.isEmpty())
1043         return false;
1044     y = rect.y() + rect.height() / 2;
1045     return true;
1046 }
1047
1048 bool FrameSelection::modify(EAlteration alter, unsigned verticalDistance, VerticalDirection direction, EUserTriggered userTriggered, CursorAlignOnScroll align)
1049 {
1050     if (!verticalDistance)
1051         return false;
1052
1053     if (userTriggered == UserTriggered) {
1054         OwnPtrWillBeRawPtr<FrameSelection> trialFrameSelection = FrameSelection::create();
1055         trialFrameSelection->setSelection(m_selection);
1056         trialFrameSelection->modify(alter, verticalDistance, direction, NotUserTriggered);
1057     }
1058
1059     willBeModified(alter, direction == DirectionUp ? DirectionBackward : DirectionForward);
1060
1061     VisiblePosition pos;
1062     LayoutUnit xPos = 0;
1063     switch (alter) {
1064     case AlterationMove:
1065         pos = VisiblePosition(direction == DirectionUp ? m_selection.start() : m_selection.end(), m_selection.affinity());
1066         xPos = lineDirectionPointForBlockDirectionNavigation(direction == DirectionUp ? START : END);
1067         m_selection.setAffinity(direction == DirectionUp ? UPSTREAM : DOWNSTREAM);
1068         break;
1069     case AlterationExtend:
1070         pos = VisiblePosition(m_selection.extent(), m_selection.affinity());
1071         xPos = lineDirectionPointForBlockDirectionNavigation(EXTENT);
1072         m_selection.setAffinity(DOWNSTREAM);
1073         break;
1074     }
1075
1076     int startY;
1077     if (!absoluteCaretY(pos, startY))
1078         return false;
1079     if (direction == DirectionUp)
1080         startY = -startY;
1081     int lastY = startY;
1082
1083     VisiblePosition result;
1084     VisiblePosition next;
1085     for (VisiblePosition p = pos; ; p = next) {
1086         if (direction == DirectionUp)
1087             next = previousLinePosition(p, xPos);
1088         else
1089             next = nextLinePosition(p, xPos);
1090
1091         if (next.isNull() || next == p)
1092             break;
1093         int nextY;
1094         if (!absoluteCaretY(next, nextY))
1095             break;
1096         if (direction == DirectionUp)
1097             nextY = -nextY;
1098         if (nextY - startY > static_cast<int>(verticalDistance))
1099             break;
1100         if (nextY >= lastY) {
1101             lastY = nextY;
1102             result = next;
1103         }
1104     }
1105
1106     if (result.isNull())
1107         return false;
1108
1109     switch (alter) {
1110     case AlterationMove:
1111         moveTo(result, userTriggered, align);
1112         break;
1113     case AlterationExtend:
1114         setExtent(result, userTriggered);
1115         break;
1116     }
1117
1118     if (userTriggered == UserTriggered)
1119         m_granularity = CharacterGranularity;
1120
1121     m_selection.setIsDirectional(shouldAlwaysUseDirectionalSelection(m_frame) || alter == AlterationExtend);
1122
1123     return true;
1124 }
1125
1126 LayoutUnit FrameSelection::lineDirectionPointForBlockDirectionNavigation(EPositionType type)
1127 {
1128     LayoutUnit x = 0;
1129
1130     if (isNone())
1131         return x;
1132
1133     Position pos;
1134     switch (type) {
1135     case START:
1136         pos = m_selection.start();
1137         break;
1138     case END:
1139         pos = m_selection.end();
1140         break;
1141     case BASE:
1142         pos = m_selection.base();
1143         break;
1144     case EXTENT:
1145         pos = m_selection.extent();
1146         break;
1147     }
1148
1149     LocalFrame* frame = pos.document()->frame();
1150     if (!frame)
1151         return x;
1152
1153     if (m_xPosForVerticalArrowNavigation == NoXPosForVerticalArrowNavigation()) {
1154         VisiblePosition visiblePosition(pos, m_selection.affinity());
1155         // VisiblePosition creation can fail here if a node containing the selection becomes visibility:hidden
1156         // after the selection is created and before this function is called.
1157         x = visiblePosition.isNotNull() ? visiblePosition.lineDirectionPointForBlockDirectionNavigation() : 0;
1158         m_xPosForVerticalArrowNavigation = x;
1159     } else
1160         x = m_xPosForVerticalArrowNavigation;
1161
1162     return x;
1163 }
1164
1165 void FrameSelection::clear()
1166 {
1167     m_granularity = CharacterGranularity;
1168     setSelection(VisibleSelection());
1169 }
1170
1171 void FrameSelection::prepareForDestruction()
1172 {
1173     m_granularity = CharacterGranularity;
1174
1175     m_caretBlinkTimer.stop();
1176
1177     RenderView* view = m_frame->contentRenderer();
1178     if (view)
1179         view->clearSelection();
1180
1181     setSelection(VisibleSelection(), CloseTyping | ClearTypingStyle | DoNotUpdateAppearance);
1182     m_previousCaretNode.clear();
1183 }
1184
1185 void FrameSelection::setStart(const VisiblePosition &pos, EUserTriggered trigger)
1186 {
1187     if (m_selection.isBaseFirst())
1188         setBase(pos, trigger);
1189     else
1190         setExtent(pos, trigger);
1191 }
1192
1193 void FrameSelection::setEnd(const VisiblePosition &pos, EUserTriggered trigger)
1194 {
1195     if (m_selection.isBaseFirst())
1196         setExtent(pos, trigger);
1197     else
1198         setBase(pos, trigger);
1199 }
1200
1201 void FrameSelection::setBase(const VisiblePosition &pos, EUserTriggered userTriggered)
1202 {
1203     const bool selectionHasDirection = true;
1204     setSelection(VisibleSelection(pos.deepEquivalent(), m_selection.extent(), pos.affinity(), selectionHasDirection), CloseTyping | ClearTypingStyle | userTriggered);
1205 }
1206
1207 void FrameSelection::setExtent(const VisiblePosition &pos, EUserTriggered userTriggered)
1208 {
1209     const bool selectionHasDirection = true;
1210     setSelection(VisibleSelection(m_selection.base(), pos.deepEquivalent(), pos.affinity(), selectionHasDirection), CloseTyping | ClearTypingStyle | userTriggered);
1211 }
1212
1213 RenderObject* FrameSelection::caretRenderer() const
1214 {
1215     return CaretBase::caretRenderer(m_selection.start().deprecatedNode());
1216 }
1217
1218 static bool isNonOrphanedCaret(const VisibleSelection& selection)
1219 {
1220     return selection.isCaret() && !selection.start().isOrphan() && !selection.end().isOrphan();
1221 }
1222
1223 LayoutRect FrameSelection::localCaretRect()
1224 {
1225     if (shouldUpdateCaretRect()) {
1226         if (!isNonOrphanedCaret(m_selection))
1227             clearCaretRect();
1228         else if (updateCaretRect(m_frame->document(), VisiblePosition(m_selection.start(), m_selection.affinity())))
1229             m_absCaretBoundsDirty = true;
1230     }
1231
1232     return localCaretRectWithoutUpdate();
1233 }
1234
1235 IntRect FrameSelection::absoluteCaretBounds()
1236 {
1237     recomputeCaretRect();
1238     return m_absCaretBounds;
1239 }
1240
1241 bool FrameSelection::recomputeCaretRect()
1242 {
1243     if (!shouldUpdateCaretRect())
1244         return false;
1245
1246     if (!m_frame || !m_frame->document()->view())
1247         return false;
1248
1249     LayoutRect oldRect = localCaretRectWithoutUpdate();
1250     LayoutRect newRect = localCaretRect();
1251     if (oldRect == newRect && !m_absCaretBoundsDirty)
1252         return false;
1253
1254     IntRect oldAbsCaretBounds = m_absCaretBounds;
1255     m_absCaretBounds = absoluteBoundsForLocalRect(m_selection.start().deprecatedNode(), localCaretRectWithoutUpdate());
1256     m_absCaretBoundsDirty = false;
1257
1258     if (oldAbsCaretBounds == m_absCaretBounds)
1259         return false;
1260
1261     if (RenderView* view = m_frame->document()->renderView()) {
1262         if (m_previousCaretNode && shouldRepaintCaret(view, m_previousCaretNode->isContentEditable()))
1263             repaintCaretForLocalRect(m_previousCaretNode.get(), oldRect);
1264         Node* node = m_selection.start().deprecatedNode();
1265         m_previousCaretNode = node;
1266         if (shouldRepaintCaret(view, isContentEditable()))
1267             repaintCaretForLocalRect(node, newRect);
1268     }
1269
1270     return true;
1271 }
1272
1273 void FrameSelection::invalidateCaretRect()
1274 {
1275     if (!isCaret())
1276         return;
1277
1278     CaretBase::invalidateCaretRect(m_selection.start().deprecatedNode(), recomputeCaretRect());
1279 }
1280
1281 void FrameSelection::paintCaret(GraphicsContext* context, const LayoutPoint& paintOffset, const LayoutRect& clipRect)
1282 {
1283     if (m_selection.isCaret() && m_caretPaint)
1284         CaretBase::paintCaret(m_selection.start().deprecatedNode(), context, paintOffset, clipRect);
1285 }
1286
1287 bool FrameSelection::contains(const LayoutPoint& point)
1288 {
1289     Document* document = m_frame->document();
1290
1291     // Treat a collapsed selection like no selection.
1292     if (!isRange())
1293         return false;
1294     if (!document->renderView())
1295         return false;
1296
1297     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::ConfusingAndOftenMisusedDisallowShadowContent);
1298     HitTestResult result(point);
1299     document->renderView()->hitTest(request, result);
1300     Node* innerNode = result.innerNode();
1301     if (!innerNode || !innerNode->renderer())
1302         return false;
1303
1304     VisiblePosition visiblePos(innerNode->renderer()->positionForPoint(result.localPoint()));
1305     if (visiblePos.isNull())
1306         return false;
1307
1308     if (m_selection.visibleStart().isNull() || m_selection.visibleEnd().isNull())
1309         return false;
1310
1311     Position start(m_selection.visibleStart().deepEquivalent());
1312     Position end(m_selection.visibleEnd().deepEquivalent());
1313     Position p(visiblePos.deepEquivalent());
1314
1315     return comparePositions(start, p) <= 0 && comparePositions(p, end) <= 0;
1316 }
1317
1318 // Workaround for the fact that it's hard to delete a frame.
1319 // Call this after doing user-triggered selections to make it easy to delete the frame you entirely selected.
1320 // Can't do this implicitly as part of every setSelection call because in some contexts it might not be good
1321 // for the focus to move to another frame. So instead we call it from places where we are selecting with the
1322 // mouse or the keyboard after setting the selection.
1323 void FrameSelection::selectFrameElementInParentIfFullySelected()
1324 {
1325     // Find the parent frame; if there is none, then we have nothing to do.
1326     Frame* parent = m_frame->tree().parent();
1327     if (!parent)
1328         return;
1329     Page* page = m_frame->page();
1330     if (!page)
1331         return;
1332
1333     // Check if the selection contains the entire frame contents; if not, then there is nothing to do.
1334     if (!isRange())
1335         return;
1336     if (!isStartOfDocument(selection().visibleStart()))
1337         return;
1338     if (!isEndOfDocument(selection().visibleEnd()))
1339         return;
1340
1341     // FIXME: This is not yet implemented for cross-process frame relationships.
1342     if (!parent->isLocalFrame())
1343         return;
1344
1345     // Get to the <iframe> or <frame> (or even <object>) element in the parent frame.
1346     // FIXME: Doesn't work for OOPI.
1347     Element* ownerElement = m_frame->deprecatedLocalOwner();
1348     if (!ownerElement)
1349         return;
1350     ContainerNode* ownerElementParent = ownerElement->parentNode();
1351     if (!ownerElementParent)
1352         return;
1353
1354     // This method's purpose is it to make it easier to select iframes (in order to delete them).  Don't do anything if the iframe isn't deletable.
1355     if (!ownerElementParent->rendererIsEditable())
1356         return;
1357
1358     // Create compute positions before and after the element.
1359     unsigned ownerElementNodeIndex = ownerElement->nodeIndex();
1360     VisiblePosition beforeOwnerElement(VisiblePosition(Position(ownerElementParent, ownerElementNodeIndex, Position::PositionIsOffsetInAnchor)));
1361     VisiblePosition afterOwnerElement(VisiblePosition(Position(ownerElementParent, ownerElementNodeIndex + 1, Position::PositionIsOffsetInAnchor), VP_UPSTREAM_IF_POSSIBLE));
1362
1363     // Focus on the parent frame, and then select from before this element to after.
1364     VisibleSelection newSelection(beforeOwnerElement, afterOwnerElement);
1365     page->focusController().setFocusedFrame(parent);
1366     toLocalFrame(parent)->selection().setSelection(newSelection);
1367 }
1368
1369 void FrameSelection::selectAll()
1370 {
1371     Document* document = m_frame->document();
1372
1373     if (isHTMLSelectElement(document->focusedElement())) {
1374         HTMLSelectElement* selectElement = toHTMLSelectElement(document->focusedElement());
1375         if (selectElement->canSelectAll()) {
1376             selectElement->selectAll();
1377             return;
1378         }
1379     }
1380
1381     RefPtrWillBeRawPtr<Node> root = nullptr;
1382     Node* selectStartTarget = 0;
1383     if (isContentEditable()) {
1384         root = highestEditableRoot(m_selection.start());
1385         if (Node* shadowRoot = m_selection.nonBoundaryShadowTreeRootNode())
1386             selectStartTarget = shadowRoot->shadowHost();
1387         else
1388             selectStartTarget = root.get();
1389     } else {
1390         root = m_selection.nonBoundaryShadowTreeRootNode();
1391         if (root)
1392             selectStartTarget = root->shadowHost();
1393         else {
1394             root = document->documentElement();
1395             selectStartTarget = document->body();
1396         }
1397     }
1398     if (!root)
1399         return;
1400
1401     if (selectStartTarget && !selectStartTarget->dispatchEvent(Event::createCancelableBubble(EventTypeNames::selectstart)))
1402         return;
1403
1404     VisibleSelection newSelection(VisibleSelection::selectionFromContentsOfNode(root.get()));
1405     setSelection(newSelection);
1406     selectFrameElementInParentIfFullySelected();
1407     notifyRendererOfSelectionChange(UserTriggered);
1408 }
1409
1410 bool FrameSelection::setSelectedRange(Range* range, EAffinity affinity, DirectoinalOption directional, SetSelectionOptions options)
1411 {
1412     if (!range || !range->startContainer() || !range->endContainer())
1413         return false;
1414     ASSERT(range->startContainer()->document() == range->endContainer()->document());
1415
1416     // Non-collapsed ranges are not allowed to start at the end of a line that is wrapped,
1417     // they start at the beginning of the next line instead
1418     m_logicalRange = nullptr;
1419     stopObservingVisibleSelectionChangeIfNecessary();
1420
1421     VisibleSelection newSelection(range, affinity, directional == Directional);
1422     setSelection(newSelection, options);
1423
1424     m_logicalRange = range->cloneRange();
1425     startObservingVisibleSelectionChange();
1426
1427     return true;
1428 }
1429
1430 PassRefPtrWillBeRawPtr<Range> FrameSelection::firstRange() const
1431 {
1432     if (m_logicalRange)
1433         return m_logicalRange->cloneRange();
1434     return m_selection.firstRange();
1435 }
1436
1437 bool FrameSelection::isInPasswordField() const
1438 {
1439     HTMLTextFormControlElement* textControl = enclosingTextFormControl(start());
1440     return isHTMLInputElement(textControl) && toHTMLInputElement(textControl)->isPasswordField();
1441 }
1442
1443 void FrameSelection::notifyAccessibilityForSelectionChange()
1444 {
1445     if (m_selection.start().isNotNull() && m_selection.end().isNotNull()) {
1446         if (AXObjectCache* cache = m_frame->document()->existingAXObjectCache())
1447             cache->selectionChanged(m_selection.start().containerNode());
1448     }
1449 }
1450
1451 void FrameSelection::focusedOrActiveStateChanged()
1452 {
1453     bool activeAndFocused = isFocusedAndActive();
1454
1455     RefPtrWillBeRawPtr<Document> document = m_frame->document();
1456     document->updateRenderTreeIfNeeded();
1457
1458     // Because RenderObject::selectionBackgroundColor() and
1459     // RenderObject::selectionForegroundColor() check if the frame is active,
1460     // we have to update places those colors were painted.
1461     if (RenderView* view = document->renderView())
1462         view->repaintSelection();
1463
1464     // Caret appears in the active frame.
1465     if (activeAndFocused)
1466         setSelectionFromNone();
1467     else
1468         m_frame->spellChecker().spellCheckAfterBlur();
1469     setCaretVisibility(activeAndFocused ? Visible : Hidden);
1470
1471     // Update for caps lock state
1472     m_frame->eventHandler().capsLockStateMayHaveChanged();
1473
1474     // We may have lost active status even though the focusElement hasn't changed
1475     // give the element a chance to recalc style if its affected by focus.
1476     if (Element* element = document->focusedElement())
1477         element->focusStateChanged();
1478
1479     // Secure keyboard entry is set by the active frame.
1480     if (document->useSecureKeyboardEntryWhenActive())
1481         setUseSecureKeyboardEntry(activeAndFocused);
1482 }
1483
1484 void FrameSelection::pageActivationChanged()
1485 {
1486     focusedOrActiveStateChanged();
1487 }
1488
1489 void FrameSelection::updateSecureKeyboardEntryIfActive()
1490 {
1491     if (m_frame->document() && isFocusedAndActive())
1492         setUseSecureKeyboardEntry(m_frame->document()->useSecureKeyboardEntryWhenActive());
1493 }
1494
1495 void FrameSelection::setUseSecureKeyboardEntry(bool enable)
1496 {
1497     if (enable)
1498         enableSecureTextInput();
1499     else
1500         disableSecureTextInput();
1501 }
1502
1503 void FrameSelection::setFocused(bool flag)
1504 {
1505     if (m_focused == flag)
1506         return;
1507     m_focused = flag;
1508
1509     focusedOrActiveStateChanged();
1510 }
1511
1512 bool FrameSelection::isFocusedAndActive() const
1513 {
1514     return m_focused && m_frame->page() && m_frame->page()->focusController().isActive();
1515 }
1516
1517 inline static bool shouldStopBlinkingDueToTypingCommand(LocalFrame* frame)
1518 {
1519     return frame->editor().lastEditCommand() && frame->editor().lastEditCommand()->shouldStopCaretBlinking();
1520 }
1521
1522 void FrameSelection::updateAppearance()
1523 {
1524     // Paint a block cursor instead of a caret in overtype mode unless the caret is at the end of a line (in this case
1525     // the FrameSelection will paint a blinking caret as usual).
1526     VisiblePosition forwardPosition;
1527     if (m_shouldShowBlockCursor && m_selection.isCaret()) {
1528         forwardPosition = modifyExtendingForward(CharacterGranularity);
1529         m_caretPaint = forwardPosition.isNull();
1530     }
1531
1532     bool caretRectChangedOrCleared = recomputeCaretRect();
1533     bool shouldBlink = shouldBlinkCaret() && forwardPosition.isNull();
1534
1535     // If the caret moved, stop the blink timer so we can restart with a
1536     // black caret in the new location.
1537     if (caretRectChangedOrCleared || !shouldBlink || shouldStopBlinkingDueToTypingCommand(m_frame)) {
1538         m_caretBlinkTimer.stop();
1539         if (!shouldBlink && m_caretPaint) {
1540             m_caretPaint = false;
1541             invalidateCaretRect();
1542         }
1543     }
1544
1545     // Start blinking with a black caret. Be sure not to restart if we're
1546     // already blinking in the right location.
1547     if (shouldBlink && !m_caretBlinkTimer.isActive()) {
1548         if (double blinkInterval = RenderTheme::theme().caretBlinkInterval())
1549             m_caretBlinkTimer.startRepeating(blinkInterval, FROM_HERE);
1550
1551         if (!m_caretPaint) {
1552             m_caretPaint = true;
1553             invalidateCaretRect();
1554         }
1555     }
1556
1557     RenderView* view = m_frame->contentRenderer();
1558     if (!view)
1559         return;
1560
1561     // Construct a new VisibleSolution, since m_selection is not necessarily valid, and the following steps
1562     // assume a valid selection. See <https://bugs.webkit.org/show_bug.cgi?id=69563> and <rdar://problem/10232866>.
1563     VisibleSelection selection(m_selection.visibleStart(), forwardPosition.isNotNull() ? forwardPosition : m_selection.visibleEnd());
1564
1565     if (!selection.isRange()) {
1566         view->clearSelection();
1567         return;
1568     }
1569
1570     // Use the rightmost candidate for the start of the selection, and the leftmost candidate for the end of the selection.
1571     // Example: foo <a>bar</a>.  Imagine that a line wrap occurs after 'foo', and that 'bar' is selected.   If we pass [foo, 3]
1572     // as the start of the selection, the selection painting code will think that content on the line containing 'foo' is selected
1573     // and will fill the gap before 'bar'.
1574     Position startPos = selection.start();
1575     Position candidate = startPos.downstream();
1576     if (candidate.isCandidate())
1577         startPos = candidate;
1578     Position endPos = selection.end();
1579     candidate = endPos.upstream();
1580     if (candidate.isCandidate())
1581         endPos = candidate;
1582
1583     // We can get into a state where the selection endpoints map to the same VisiblePosition when a selection is deleted
1584     // because we don't yet notify the FrameSelection of text removal.
1585     if (startPos.isNotNull() && endPos.isNotNull() && selection.visibleStart() != selection.visibleEnd()) {
1586         RenderObject* startRenderer = startPos.deprecatedNode()->renderer();
1587         RenderObject* endRenderer = endPos.deprecatedNode()->renderer();
1588         if (startRenderer->view() == view && endRenderer->view() == view)
1589             view->setSelection(startRenderer, startPos.deprecatedEditingOffset(), endRenderer, endPos.deprecatedEditingOffset());
1590     }
1591 }
1592
1593 void FrameSelection::setCaretVisibility(CaretVisibility visibility)
1594 {
1595     if (caretVisibility() == visibility)
1596         return;
1597
1598     m_frame->document()->updateLayoutIgnorePendingStylesheets();
1599     if (m_caretPaint) {
1600         m_caretPaint = false;
1601         invalidateCaretRect();
1602     }
1603     CaretBase::setCaretVisibility(visibility);
1604
1605     updateAppearance();
1606 }
1607
1608 bool FrameSelection::shouldBlinkCaret() const
1609 {
1610     if (!caretIsVisible() || !isCaret())
1611         return false;
1612
1613     if (m_frame->settings() && m_frame->settings()->caretBrowsingEnabled())
1614         return false;
1615
1616     Node* root = rootEditableElement();
1617     if (!root)
1618         return false;
1619
1620     Element* focusedElement = root->document().focusedElement();
1621     if (!focusedElement)
1622         return false;
1623
1624     return focusedElement->containsIncludingShadowDOM(m_selection.start().anchorNode());
1625 }
1626
1627 void FrameSelection::caretBlinkTimerFired(Timer<FrameSelection>*)
1628 {
1629     ASSERT(caretIsVisible());
1630     ASSERT(isCaret());
1631     bool caretPaint = m_caretPaint;
1632     if (isCaretBlinkingSuspended() && caretPaint)
1633         return;
1634     m_caretPaint = !caretPaint;
1635     invalidateCaretRect();
1636 }
1637
1638 void FrameSelection::notifyRendererOfSelectionChange(EUserTriggered userTriggered)
1639 {
1640     m_frame->document()->updateRenderTreeIfNeeded();
1641
1642     if (HTMLTextFormControlElement* textControl = enclosingTextFormControl(start()))
1643         textControl->selectionChanged(userTriggered == UserTriggered);
1644 }
1645
1646 // Helper function that tells whether a particular node is an element that has an entire
1647 // LocalFrame and FrameView, a <frame>, <iframe>, or <object>.
1648 static bool isFrameElement(const Node* n)
1649 {
1650     if (!n)
1651         return false;
1652     RenderObject* renderer = n->renderer();
1653     if (!renderer || !renderer->isWidget())
1654         return false;
1655     Widget* widget = toRenderWidget(renderer)->widget();
1656     return widget && widget->isFrameView();
1657 }
1658
1659 void FrameSelection::setFocusedNodeIfNeeded()
1660 {
1661     if (isNone() || !isFocused())
1662         return;
1663
1664     bool caretBrowsing = m_frame->settings() && m_frame->settings()->caretBrowsingEnabled();
1665     if (caretBrowsing) {
1666         if (Element* anchor = enclosingAnchorElement(base())) {
1667             m_frame->page()->focusController().setFocusedElement(anchor, m_frame);
1668             return;
1669         }
1670     }
1671
1672     if (Element* target = rootEditableElement()) {
1673         // Walk up the DOM tree to search for a node to focus.
1674         while (target) {
1675             // We don't want to set focus on a subframe when selecting in a parent frame,
1676             // so add the !isFrameElement check here. There's probably a better way to make this
1677             // work in the long term, but this is the safest fix at this time.
1678             if (target->isMouseFocusable() && !isFrameElement(target)) {
1679                 m_frame->page()->focusController().setFocusedElement(target, m_frame);
1680                 return;
1681             }
1682             target = target->parentOrShadowHostElement();
1683         }
1684         m_frame->document()->setFocusedElement(nullptr);
1685     }
1686
1687     if (caretBrowsing)
1688         m_frame->page()->focusController().setFocusedElement(0, m_frame);
1689 }
1690
1691 static String extractSelectedText(const FrameSelection& selection, TextIteratorBehavior behavior)
1692 {
1693     // We remove '\0' characters because they are not visibly rendered to the user.
1694     return plainText(selection.toNormalizedRange().get(), behavior).replace(0, "");
1695 }
1696
1697 String FrameSelection::selectedText() const
1698 {
1699     return extractSelectedText(*this, TextIteratorDefaultBehavior);
1700 }
1701
1702 String FrameSelection::selectedTextForClipboard() const
1703 {
1704     if (m_frame->settings() && m_frame->settings()->selectionIncludesAltImageText())
1705         return extractSelectedText(*this, TextIteratorEmitsImageAltText);
1706     return selectedText();
1707 }
1708
1709 FloatRect FrameSelection::bounds(bool clipToVisibleContent) const
1710 {
1711     m_frame->document()->updateRenderTreeIfNeeded();
1712
1713     FrameView* view = m_frame->view();
1714     RenderView* renderView = m_frame->contentRenderer();
1715
1716     if (!view || !renderView)
1717         return FloatRect();
1718
1719     LayoutRect selectionRect = renderView->selectionBounds(clipToVisibleContent);
1720     return clipToVisibleContent ? intersection(selectionRect, view->visibleContentRect()) : selectionRect;
1721 }
1722
1723 static inline HTMLFormElement* associatedFormElement(HTMLElement& element)
1724 {
1725     if (isHTMLFormElement(element))
1726         return &toHTMLFormElement(element);
1727     return element.formOwner();
1728 }
1729
1730 // Scans logically forward from "start", including any child frames.
1731 static HTMLFormElement* scanForForm(Node* start)
1732 {
1733     if (!start)
1734         return 0;
1735
1736     HTMLElement* element = start->isHTMLElement() ? toHTMLElement(start) : Traversal<HTMLElement>::next(*start);
1737     for (; element; element = Traversal<HTMLElement>::next(*element)) {
1738         if (HTMLFormElement* form = associatedFormElement(*element))
1739             return form;
1740
1741         if (isHTMLFrameElementBase(*element)) {
1742             Node* childDocument = toHTMLFrameElementBase(*element).contentDocument();
1743             if (HTMLFormElement* frameResult = scanForForm(childDocument))
1744                 return frameResult;
1745         }
1746     }
1747     return 0;
1748 }
1749
1750 // We look for either the form containing the current focus, or for one immediately after it
1751 HTMLFormElement* FrameSelection::currentForm() const
1752 {
1753     // Start looking either at the active (first responder) node, or where the selection is.
1754     Node* start = m_frame->document()->focusedElement();
1755     if (!start)
1756         start = this->start().deprecatedNode();
1757     if (!start)
1758         return 0;
1759
1760     // Try walking up the node tree to find a form element.
1761     for (HTMLElement* element = Traversal<HTMLElement>::firstAncestorOrSelf(*start); element; element = Traversal<HTMLElement>::firstAncestor(*element)) {
1762         if (HTMLFormElement* form = associatedFormElement(*element))
1763             return form;
1764     }
1765
1766     // Try walking forward in the node tree to find a form element.
1767     return scanForForm(start);
1768 }
1769
1770 void FrameSelection::revealSelection(const ScrollAlignment& alignment, RevealExtentOption revealExtentOption)
1771 {
1772     LayoutRect rect;
1773
1774     switch (selectionType()) {
1775     case NoSelection:
1776         return;
1777     case CaretSelection:
1778         rect = absoluteCaretBounds();
1779         break;
1780     case RangeSelection:
1781         rect = revealExtentOption == RevealExtent ? VisiblePosition(extent()).absoluteCaretBounds() : enclosingIntRect(bounds(false));
1782         break;
1783     }
1784
1785     Position start = this->start();
1786     ASSERT(start.deprecatedNode());
1787     if (start.deprecatedNode() && start.deprecatedNode()->renderer()) {
1788         // FIXME: This code only handles scrolling the startContainer's layer, but
1789         // the selection rect could intersect more than just that.
1790         // See <rdar://problem/4799899>.
1791         if (start.deprecatedNode()->renderer()->scrollRectToVisible(rect, alignment, alignment))
1792             updateAppearance();
1793     }
1794 }
1795
1796 void FrameSelection::setSelectionFromNone()
1797 {
1798     // Put a caret inside the body if the entire frame is editable (either the
1799     // entire WebView is editable or designMode is on for this document).
1800
1801     Document* document = m_frame->document();
1802     bool caretBrowsing = m_frame->settings() && m_frame->settings()->caretBrowsingEnabled();
1803     if (!isNone() || !(document->rendererIsEditable() || caretBrowsing))
1804         return;
1805
1806     Node* node = document->documentElement();
1807     if (!node)
1808         return;
1809     Node* body = isHTMLBodyElement(*node) ? node : Traversal<HTMLBodyElement>::next(*node);
1810     if (body)
1811         setSelection(VisibleSelection(firstPositionInOrBeforeNode(body), DOWNSTREAM));
1812 }
1813
1814 bool FrameSelection::dispatchSelectStart()
1815 {
1816     Node* selectStartTarget = m_selection.extent().containerNode();
1817     if (!selectStartTarget)
1818         return true;
1819
1820     return selectStartTarget->dispatchEvent(Event::createCancelableBubble(EventTypeNames::selectstart));
1821 }
1822
1823 void FrameSelection::setShouldShowBlockCursor(bool shouldShowBlockCursor)
1824 {
1825     m_shouldShowBlockCursor = shouldShowBlockCursor;
1826
1827     m_frame->document()->updateLayoutIgnorePendingStylesheets();
1828
1829     updateAppearance();
1830 }
1831
1832 void FrameSelection::didChangeVisibleSelection()
1833 {
1834     ASSERT(m_observingVisibleSelection);
1835     // Invalidate the logical range when the underlying VisibleSelection has changed.
1836     m_logicalRange = nullptr;
1837     m_selection.clearChangeObserver();
1838     m_observingVisibleSelection = false;
1839 }
1840
1841 VisibleSelection FrameSelection::validateSelection(const VisibleSelection& selection)
1842 {
1843     if (!m_frame || selection.isNone())
1844         return selection;
1845
1846     Position base = selection.base();
1847     Position extent = selection.extent();
1848     bool isBaseValid = base.document() == m_frame->document();
1849     bool isExtentValid = extent.document() == m_frame->document();
1850
1851     if (isBaseValid && isExtentValid)
1852         return selection;
1853
1854     VisibleSelection newSelection;
1855     if (isBaseValid) {
1856         newSelection.setWithoutValidation(base, base);
1857     } else if (isExtentValid) {
1858         newSelection.setWithoutValidation(extent, extent);
1859     }
1860     return newSelection;
1861 }
1862
1863 void FrameSelection::startObservingVisibleSelectionChange()
1864 {
1865     ASSERT(!m_observingVisibleSelection);
1866     m_selection.setChangeObserver(*this);
1867     m_observingVisibleSelection = true;
1868 }
1869
1870 void FrameSelection::stopObservingVisibleSelectionChangeIfNecessary()
1871 {
1872     if (m_observingVisibleSelection) {
1873         m_selection.clearChangeObserver();
1874         m_observingVisibleSelection = false;
1875     }
1876 }
1877
1878 #ifndef NDEBUG
1879
1880 void FrameSelection::formatForDebugger(char* buffer, unsigned length) const
1881 {
1882     m_selection.formatForDebugger(buffer, length);
1883 }
1884
1885 void FrameSelection::showTreeForThis() const
1886 {
1887     m_selection.showTreeForThis();
1888 }
1889
1890 #endif
1891
1892 void FrameSelection::trace(Visitor* visitor)
1893 {
1894     visitor->trace(m_selection);
1895     visitor->trace(m_originalBase);
1896     visitor->trace(m_logicalRange);
1897     visitor->trace(m_previousCaretNode);
1898     visitor->trace(m_typingStyle);
1899     VisibleSelection::ChangeObserver::trace(visitor);
1900 }
1901
1902 }
1903
1904 #ifndef NDEBUG
1905
1906 void showTree(const WebCore::FrameSelection& sel)
1907 {
1908     sel.showTreeForThis();
1909 }
1910
1911 void showTree(const WebCore::FrameSelection* sel)
1912 {
1913     if (sel)
1914         sel->showTreeForThis();
1915 }
1916
1917 #endif