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