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