Move test for contained caret offset to RenderTextLineBoxes
[WebKit-https.git] / Source / WebCore / rendering / RenderText.cpp
1 /*
2  * (C) 1999 Lars Knoll (knoll@kde.org)
3  * (C) 2000 Dirk Mueller (mueller@kde.org)
4  * Copyright (C) 2004, 2005, 2006, 2007, 2013 Apple Inc. All rights reserved.
5  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
6  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #include "config.h"
26 #include "RenderText.h"
27
28 #include "AXObjectCache.h"
29 #include "EllipsisBox.h"
30 #include "FloatQuad.h"
31 #include "Frame.h"
32 #include "FrameView.h"
33 #include "Hyphenation.h"
34 #include "InlineTextBox.h"
35 #include "Range.h"
36 #include "RenderArena.h"
37 #include "RenderBlock.h"
38 #include "RenderCombineText.h"
39 #include "RenderLayer.h"
40 #include "RenderView.h"
41 #include "Settings.h"
42 #include "Text.h"
43 #include "TextBreakIterator.h"
44 #include "TextResourceDecoder.h"
45 #include "VisiblePosition.h"
46 #include "break_lines.h"
47 #include <wtf/text/StringBuffer.h>
48 #include <wtf/unicode/CharacterNames.h>
49
50 using namespace std;
51 using namespace WTF;
52 using namespace Unicode;
53
54 namespace WebCore {
55
56 struct SameSizeAsRenderText : public RenderObject {
57     uint32_t bitfields : 16;
58 #if ENABLE(IOS_TEXT_AUTOSIZING)
59     float candidateTextSize;
60 #endif
61     float widths[4];
62     String text;
63     void* pointers[2];
64 };
65
66 COMPILE_ASSERT(sizeof(RenderText) == sizeof(SameSizeAsRenderText), RenderText_should_stay_small);
67
68 class SecureTextTimer;
69 typedef HashMap<RenderText*, SecureTextTimer*> SecureTextTimerMap;
70 static SecureTextTimerMap* gSecureTextTimers = 0;
71
72 class SecureTextTimer : public TimerBase {
73 public:
74     SecureTextTimer(RenderText* renderText)
75         : m_renderText(renderText)
76         , m_lastTypedCharacterOffset(-1)
77     {
78     }
79
80     void restartWithNewText(unsigned lastTypedCharacterOffset)
81     {
82         m_lastTypedCharacterOffset = lastTypedCharacterOffset;
83         const Settings& settings = m_renderText->frame().settings();
84         startOneShot(settings.passwordEchoDurationInSeconds());
85     }
86     void invalidate() { m_lastTypedCharacterOffset = -1; }
87     unsigned lastTypedCharacterOffset() { return m_lastTypedCharacterOffset; }
88
89 private:
90     virtual void fired()
91     {
92         ASSERT(gSecureTextTimers->contains(m_renderText));
93         m_renderText->setText(m_renderText->text(), true /* forcing setting text as it may be masked later */);
94     }
95
96     RenderText* m_renderText;
97     int m_lastTypedCharacterOffset;
98 };
99
100 static void makeCapitalized(String* string, UChar previous)
101 {
102     // FIXME: Need to change this to use u_strToTitle instead of u_totitle and to consider locale.
103
104     if (string->isNull())
105         return;
106
107     unsigned length = string->length();
108     const StringImpl& stringImpl = *string->impl();
109
110     if (length >= numeric_limits<unsigned>::max())
111         CRASH();
112
113     StringBuffer<UChar> stringWithPrevious(length + 1);
114     stringWithPrevious[0] = previous == noBreakSpace ? ' ' : previous;
115     for (unsigned i = 1; i < length + 1; i++) {
116         // Replace &nbsp with a real space since ICU no longer treats &nbsp as a word separator.
117         if (stringImpl[i - 1] == noBreakSpace)
118             stringWithPrevious[i] = ' ';
119         else
120             stringWithPrevious[i] = stringImpl[i - 1];
121     }
122
123     TextBreakIterator* boundary = wordBreakIterator(stringWithPrevious.characters(), length + 1);
124     if (!boundary)
125         return;
126
127     StringBuilder result;
128     result.reserveCapacity(length);
129
130     int32_t endOfWord;
131     int32_t startOfWord = textBreakFirst(boundary);
132     for (endOfWord = textBreakNext(boundary); endOfWord != TextBreakDone; startOfWord = endOfWord, endOfWord = textBreakNext(boundary)) {
133         if (startOfWord) // Ignore first char of previous string
134             result.append(stringImpl[startOfWord - 1] == noBreakSpace ? noBreakSpace : u_totitle(stringWithPrevious[startOfWord]));
135         for (int i = startOfWord + 1; i < endOfWord; i++)
136             result.append(stringImpl[i - 1]);
137     }
138
139     *string = result.toString();
140 }
141
142 RenderText::RenderText(Text& textNode, const String& text)
143     : RenderObject(textNode)
144     , m_hasTab(false)
145     , m_linesDirty(false)
146     , m_containsReversedText(false)
147     , m_isAllASCII(text.containsOnlyASCII())
148     , m_knownToHaveNoOverflowAndNoFallbackFonts(false)
149     , m_useBackslashAsYenSymbol(false)
150 #if ENABLE(IOS_TEXT_AUTOSIZING)
151     , m_candidateComputedTextSize(0)
152 #endif
153     , m_minWidth(-1)
154     , m_maxWidth(-1)
155     , m_beginMinWidth(0)
156     , m_endMinWidth(0)
157     , m_text(text)
158 {
159     ASSERT(!m_text.isNull());
160     setIsText();
161     m_canUseSimpleFontCodePath = computeCanUseSimpleFontCodePath();
162     view().frameView().incrementVisuallyNonEmptyCharacterCount(textLength());
163 }
164
165 RenderText::RenderText(Document& document, const String& text)
166     : RenderObject(document)
167     , m_hasTab(false)
168     , m_linesDirty(false)
169     , m_containsReversedText(false)
170     , m_isAllASCII(text.containsOnlyASCII())
171     , m_knownToHaveNoOverflowAndNoFallbackFonts(false)
172     , m_useBackslashAsYenSymbol(false)
173 #if ENABLE(IOS_TEXT_AUTOSIZING)
174     , m_candidateComputedTextSize(0)
175 #endif
176     , m_minWidth(-1)
177     , m_maxWidth(-1)
178     , m_beginMinWidth(0)
179     , m_endMinWidth(0)
180     , m_text(text)
181 {
182     ASSERT(!m_text.isNull());
183     setIsText();
184     m_canUseSimpleFontCodePath = computeCanUseSimpleFontCodePath();
185     view().frameView().incrementVisuallyNonEmptyCharacterCount(textLength());
186 }
187
188 #ifndef NDEBUG
189
190 RenderText::~RenderText()
191 {
192 }
193
194 #endif
195
196 const char* RenderText::renderName() const
197 {
198     return "RenderText";
199 }
200
201 Text* RenderText::textNode() const
202 {
203     return toText(RenderObject::node());
204 }
205
206 bool RenderText::isTextFragment() const
207 {
208     return false;
209 }
210
211 bool RenderText::computeUseBackslashAsYenSymbol() const
212 {
213     const RenderStyle& style = *this->style();
214     const FontDescription& fontDescription = style.font().fontDescription();
215     if (style.font().useBackslashAsYenSymbol())
216         return true;
217     if (fontDescription.isSpecifiedFont())
218         return false;
219     const TextEncoding* encoding = document().decoder() ? &document().decoder()->encoding() : 0;
220     if (encoding && encoding->backslashAsCurrencySymbol() != '\\')
221         return true;
222     return false;
223 }
224
225 void RenderText::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
226 {
227     // There is no need to ever schedule repaints from a style change of a text run, since
228     // we already did this for the parent of the text run.
229     // We do have to schedule layouts, though, since a style change can force us to
230     // need to relayout.
231     if (diff == StyleDifferenceLayout) {
232         setNeedsLayoutAndPrefWidthsRecalc();
233         m_knownToHaveNoOverflowAndNoFallbackFonts = false;
234     }
235
236     RenderStyle* newStyle = style();
237     bool needsResetText = false;
238     if (!oldStyle) {
239         m_useBackslashAsYenSymbol = computeUseBackslashAsYenSymbol();
240         needsResetText = m_useBackslashAsYenSymbol;
241     } else if (oldStyle->font().useBackslashAsYenSymbol() != newStyle->font().useBackslashAsYenSymbol()) {
242         m_useBackslashAsYenSymbol = computeUseBackslashAsYenSymbol();
243         needsResetText = true;
244     }
245
246     ETextTransform oldTransform = oldStyle ? oldStyle->textTransform() : TTNONE;
247     ETextSecurity oldSecurity = oldStyle ? oldStyle->textSecurity() : TSNONE;
248     if (needsResetText || oldTransform != newStyle->textTransform() || oldSecurity != newStyle->textSecurity()) 
249         transformText();
250 }
251
252 void RenderText::removeAndDestroyTextBoxes()
253 {
254     if (!documentBeingDestroyed())
255         m_lineBoxes.removeAllFromParent(*this);
256     m_lineBoxes.deleteAll(*this);
257 }
258
259 void RenderText::willBeDestroyed()
260 {
261     if (SecureTextTimer* secureTextTimer = gSecureTextTimers ? gSecureTextTimers->take(this) : 0)
262         delete secureTextTimer;
263
264     removeAndDestroyTextBoxes();
265     RenderObject::willBeDestroyed();
266 }
267
268 String RenderText::originalText() const
269 {
270     return textNode() ? textNode()->data() : String();
271 }
272
273 void RenderText::absoluteRects(Vector<IntRect>& rects, const LayoutPoint& accumulatedOffset) const
274 {
275     rects.appendVector(m_lineBoxes.absoluteRects(accumulatedOffset));
276 }
277
278 Vector<IntRect> RenderText::absoluteRectsForRange(unsigned start, unsigned end, bool useSelectionHeight, bool* wasFixed) const
279 {
280     // Work around signed/unsigned issues. This function takes unsigneds, and is often passed UINT_MAX
281     // to mean "all the way to the end". InlineTextBox coordinates are unsigneds, so changing this 
282     // function to take ints causes various internal mismatches. But selectionRect takes ints, and 
283     // passing UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take unsigneds, but 
284     // that would cause many ripple effects, so for now we'll just clamp our unsigned parameters to INT_MAX.
285     ASSERT(end == UINT_MAX || end <= INT_MAX);
286     ASSERT(start <= INT_MAX);
287     start = min(start, static_cast<unsigned>(INT_MAX));
288     end = min(end, static_cast<unsigned>(INT_MAX));
289     
290     return m_lineBoxes.absoluteRectsForRange(*this, start, end, useSelectionHeight, wasFixed);
291 }
292
293 Vector<FloatQuad> RenderText::absoluteQuadsClippedToEllipsis() const
294 {
295     return m_lineBoxes.absoluteQuads(*this, nullptr, RenderTextLineBoxes::ClipToEllipsis);
296 }
297
298 void RenderText::absoluteQuads(Vector<FloatQuad>& quads, bool* wasFixed) const
299 {
300     quads.appendVector(m_lineBoxes.absoluteQuads(*this, wasFixed, RenderTextLineBoxes::NoClipping));
301 }
302
303 Vector<FloatQuad> RenderText::absoluteQuadsForRange(unsigned start, unsigned end, bool useSelectionHeight, bool* wasFixed) const
304 {
305     // Work around signed/unsigned issues. This function takes unsigneds, and is often passed UINT_MAX
306     // to mean "all the way to the end". InlineTextBox coordinates are unsigneds, so changing this 
307     // function to take ints causes various internal mismatches. But selectionRect takes ints, and 
308     // passing UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take unsigneds, but 
309     // that would cause many ripple effects, so for now we'll just clamp our unsigned parameters to INT_MAX.
310     ASSERT(end == UINT_MAX || end <= INT_MAX);
311     ASSERT(start <= INT_MAX);
312     start = min(start, static_cast<unsigned>(INT_MAX));
313     end = min(end, static_cast<unsigned>(INT_MAX));
314     
315     return m_lineBoxes.absoluteQuadsForRange(*this, start, end, useSelectionHeight, wasFixed);
316 }
317
318 VisiblePosition RenderText::positionForPoint(const LayoutPoint& point)
319 {
320     return m_lineBoxes.positionForPoint(*this, point);
321 }
322
323 LayoutRect RenderText::localCaretRect(InlineBox* inlineBox, int caretOffset, LayoutUnit* extraWidthToEndOfLine)
324 {
325     if (!inlineBox)
326         return LayoutRect();
327
328     InlineTextBox* box = toInlineTextBox(inlineBox);
329     float left = box->positionForOffset(caretOffset);
330     return box->root().computeCaretRect(left, caretWidth, extraWidthToEndOfLine);
331 }
332
333 ALWAYS_INLINE float RenderText::widthFromCache(const Font& f, int start, int len, float xPos, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow, const RenderStyle& style) const
334 {
335     if (style.hasTextCombine() && isCombineText()) {
336         const RenderCombineText& combineText = toRenderCombineText(*this);
337         if (combineText.isCombined())
338             return combineText.combinedTextWidth(f);
339     }
340
341     if (f.isFixedPitch() && !f.isSmallCaps() && m_isAllASCII && (!glyphOverflow || !glyphOverflow->computeBounds)) {
342         float monospaceCharacterWidth = f.spaceWidth();
343         float w = 0;
344         bool isSpace;
345         ASSERT(m_text);
346         StringImpl& text = *m_text.impl();
347         for (int i = start; i < start + len; i++) {
348             char c = text[i];
349             if (c <= ' ') {
350                 if (c == ' ' || c == '\n') {
351                     w += monospaceCharacterWidth;
352                     isSpace = true;
353                 } else if (c == '\t') {
354                     if (style.collapseWhiteSpace()) {
355                         w += monospaceCharacterWidth;
356                         isSpace = true;
357                     } else {
358                         w += f.tabWidth(style.tabSize(), xPos + w);
359                         isSpace = false;
360                     }
361                 } else
362                     isSpace = false;
363             } else {
364                 w += monospaceCharacterWidth;
365                 isSpace = false;
366             }
367             if (isSpace && i > start)
368                 w += f.wordSpacing();
369         }
370         return w;
371     }
372
373     TextRun run = RenderBlock::constructTextRun(const_cast<RenderText*>(this), f, this, start, len, style);
374     run.setCharactersLength(textLength() - start);
375     ASSERT(run.charactersLength() >= run.length());
376
377     run.setCharacterScanForCodePath(!canUseSimpleFontCodePath());
378     run.setTabSize(!style.collapseWhiteSpace(), style.tabSize());
379     run.setXPos(xPos);
380     return f.width(run, fallbackFonts, glyphOverflow);
381 }
382
383 void RenderText::trimmedPrefWidths(float leadWidth,
384                                    float& beginMinW, bool& beginWS,
385                                    float& endMinW, bool& endWS,
386                                    bool& hasBreakableChar, bool& hasBreak,
387                                    float& beginMaxW, float& endMaxW,
388                                    float& minW, float& maxW, bool& stripFrontSpaces)
389 {
390     const RenderStyle& style = *this->style();
391     bool collapseWhiteSpace = style.collapseWhiteSpace();
392     if (!collapseWhiteSpace)
393         stripFrontSpaces = false;
394
395     if (m_hasTab || preferredLogicalWidthsDirty())
396         computePreferredLogicalWidths(leadWidth);
397
398     beginWS = !stripFrontSpaces && m_hasBeginWS;
399     endWS = m_hasEndWS;
400
401     int len = textLength();
402
403     if (!len || (stripFrontSpaces && text()->containsOnlyWhitespace())) {
404         beginMinW = 0;
405         endMinW = 0;
406         beginMaxW = 0;
407         endMaxW = 0;
408         minW = 0;
409         maxW = 0;
410         hasBreak = false;
411         return;
412     }
413
414     minW = m_minWidth;
415     maxW = m_maxWidth;
416
417     beginMinW = m_beginMinWidth;
418     endMinW = m_endMinWidth;
419
420     hasBreakableChar = m_hasBreakableChar;
421     hasBreak = m_hasBreak;
422
423     ASSERT(m_text);
424     StringImpl& text = *m_text.impl();
425     if (text[0] == ' ' || (text[0] == '\n' && !style.preserveNewline()) || text[0] == '\t') {
426         const Font& font = style.font(); // FIXME: This ignores first-line.
427         if (stripFrontSpaces) {
428             const UChar space = ' ';
429             float spaceWidth = font.width(RenderBlock::constructTextRun(this, font, &space, 1, style));
430             maxW -= spaceWidth;
431         } else
432             maxW += font.wordSpacing();
433     }
434
435     stripFrontSpaces = collapseWhiteSpace && m_hasEndWS;
436
437     if (!style.autoWrap() || minW > maxW)
438         minW = maxW;
439
440     // Compute our max widths by scanning the string for newlines.
441     if (hasBreak) {
442         const Font& f = style.font(); // FIXME: This ignores first-line.
443         bool firstLine = true;
444         beginMaxW = maxW;
445         endMaxW = maxW;
446         for (int i = 0; i < len; i++) {
447             int linelen = 0;
448             while (i + linelen < len && text[i + linelen] != '\n')
449                 linelen++;
450
451             if (linelen) {
452                 endMaxW = widthFromCache(f, i, linelen, leadWidth + endMaxW, 0, 0, style);
453                 if (firstLine) {
454                     firstLine = false;
455                     leadWidth = 0;
456                     beginMaxW = endMaxW;
457                 }
458                 i += linelen;
459             } else if (firstLine) {
460                 beginMaxW = 0;
461                 firstLine = false;
462                 leadWidth = 0;
463             }
464
465             if (i == len - 1)
466                 // A <pre> run that ends with a newline, as in, e.g.,
467                 // <pre>Some text\n\n<span>More text</pre>
468                 endMaxW = 0;
469         }
470     }
471 }
472
473 static inline bool isSpaceAccordingToStyle(UChar c, const RenderStyle& style)
474 {
475     return c == ' ' || (c == noBreakSpace && style.nbspMode() == SPACE);
476 }
477
478 float RenderText::minLogicalWidth() const
479 {
480     if (preferredLogicalWidthsDirty())
481         const_cast<RenderText*>(this)->computePreferredLogicalWidths(0);
482         
483     return m_minWidth;
484 }
485
486 float RenderText::maxLogicalWidth() const
487 {
488     if (preferredLogicalWidthsDirty())
489         const_cast<RenderText*>(this)->computePreferredLogicalWidths(0);
490         
491     return m_maxWidth;
492 }
493
494 void RenderText::computePreferredLogicalWidths(float leadWidth)
495 {
496     HashSet<const SimpleFontData*> fallbackFonts;
497     GlyphOverflow glyphOverflow;
498     computePreferredLogicalWidths(leadWidth, fallbackFonts, glyphOverflow);
499     if (fallbackFonts.isEmpty() && !glyphOverflow.left && !glyphOverflow.right && !glyphOverflow.top && !glyphOverflow.bottom)
500         m_knownToHaveNoOverflowAndNoFallbackFonts = true;
501 }
502
503 static inline float hyphenWidth(RenderText* renderer, const Font& font)
504 {
505     RenderStyle* style = renderer->style();
506     return font.width(RenderBlock::constructTextRun(renderer, font, style->hyphenString().string(), *style));
507 }
508
509 static float maxWordFragmentWidth(RenderText* renderer, const RenderStyle& style, const Font& font, const UChar* word, int wordLength, int minimumPrefixLength, int minimumSuffixLength, int& suffixStart, HashSet<const SimpleFontData*>& fallbackFonts, GlyphOverflow& glyphOverflow)
510 {
511     suffixStart = 0;
512     if (wordLength <= minimumSuffixLength)
513         return 0;
514
515     Vector<int, 8> hyphenLocations;
516     int hyphenLocation = wordLength - minimumSuffixLength;
517     while ((hyphenLocation = lastHyphenLocation(word, wordLength, hyphenLocation, style.locale())) >= minimumPrefixLength)
518         hyphenLocations.append(hyphenLocation);
519
520     if (hyphenLocations.isEmpty())
521         return 0;
522
523     hyphenLocations.reverse();
524
525     float minimumFragmentWidthToConsider = font.pixelSize() * 5 / 4 + hyphenWidth(renderer, font);
526     float maxFragmentWidth = 0;
527     for (size_t k = 0; k < hyphenLocations.size(); ++k) {
528         int fragmentLength = hyphenLocations[k] - suffixStart;
529         StringBuilder fragmentWithHyphen;
530         fragmentWithHyphen.append(word + suffixStart, fragmentLength);
531         fragmentWithHyphen.append(style.hyphenString());
532
533         TextRun run = RenderBlock::constructTextRun(renderer, font, fragmentWithHyphen.characters(), fragmentWithHyphen.length(), style);
534         run.setCharactersLength(fragmentWithHyphen.length());
535         run.setCharacterScanForCodePath(!renderer->canUseSimpleFontCodePath());
536         float fragmentWidth = font.width(run, &fallbackFonts, &glyphOverflow);
537
538         // Narrow prefixes are ignored. See tryHyphenating in RenderBlockLineLayout.cpp.
539         if (fragmentWidth <= minimumFragmentWidthToConsider)
540             continue;
541
542         suffixStart += fragmentLength;
543         maxFragmentWidth = max(maxFragmentWidth, fragmentWidth);
544     }
545
546     return maxFragmentWidth;
547 }
548
549 void RenderText::computePreferredLogicalWidths(float leadWidth, HashSet<const SimpleFontData*>& fallbackFonts, GlyphOverflow& glyphOverflow)
550 {
551     ASSERT(m_hasTab || preferredLogicalWidthsDirty() || !m_knownToHaveNoOverflowAndNoFallbackFonts);
552
553     m_minWidth = 0;
554     m_beginMinWidth = 0;
555     m_endMinWidth = 0;
556     m_maxWidth = 0;
557
558     float currMinWidth = 0;
559     float currMaxWidth = 0;
560     m_hasBreakableChar = false;
561     m_hasBreak = false;
562     m_hasTab = false;
563     m_hasBeginWS = false;
564     m_hasEndWS = false;
565
566     const RenderStyle& style = *this->style();
567     const Font& f = style.font(); // FIXME: This ignores first-line.
568     float wordSpacing = style.wordSpacing();
569     int len = textLength();
570     LazyLineBreakIterator breakIterator(m_text, style.locale());
571     bool needsWordSpacing = false;
572     bool ignoringSpaces = false;
573     bool isSpace = false;
574     bool firstWord = true;
575     bool firstLine = true;
576     int nextBreakable = -1;
577     int lastWordBoundary = 0;
578
579     // Non-zero only when kerning is enabled, in which case we measure words with their trailing
580     // space, then subtract its width.
581     float wordTrailingSpaceWidth = f.typesettingFeatures() & Kerning ? f.width(RenderBlock::constructTextRun(this, f, &space, 1, style), &fallbackFonts) + wordSpacing : 0;
582
583     // If automatic hyphenation is allowed, we keep track of the width of the widest word (or word
584     // fragment) encountered so far, and only try hyphenating words that are wider.
585     float maxWordWidth = numeric_limits<float>::max();
586     int minimumPrefixLength = 0;
587     int minimumSuffixLength = 0;
588     if (style.hyphens() == HyphensAuto && canHyphenate(style.locale())) {
589         maxWordWidth = 0;
590
591         // Map 'hyphenate-limit-{before,after}: auto;' to 2.
592         minimumPrefixLength = style.hyphenationLimitBefore();
593         if (minimumPrefixLength < 0)
594             minimumPrefixLength = 2;
595
596         minimumSuffixLength = style.hyphenationLimitAfter();
597         if (minimumSuffixLength < 0)
598             minimumSuffixLength = 2;
599     }
600
601     int firstGlyphLeftOverflow = -1;
602
603     bool breakNBSP = style.autoWrap() && style.nbspMode() == SPACE;
604     bool breakAll = (style.wordBreak() == BreakAllWordBreak || style.wordBreak() == BreakWordBreak) && style.autoWrap();
605
606     for (int i = 0; i < len; i++) {
607         UChar c = characterAt(i);
608
609         bool previousCharacterIsSpace = isSpace;
610
611         bool isNewline = false;
612         if (c == '\n') {
613             if (style.preserveNewline()) {
614                 m_hasBreak = true;
615                 isNewline = true;
616                 isSpace = false;
617             } else
618                 isSpace = true;
619         } else if (c == '\t') {
620             if (!style.collapseWhiteSpace()) {
621                 m_hasTab = true;
622                 isSpace = false;
623             } else
624                 isSpace = true;
625         } else
626             isSpace = c == ' ';
627
628         if ((isSpace || isNewline) && !i)
629             m_hasBeginWS = true;
630         if ((isSpace || isNewline) && i == len - 1)
631             m_hasEndWS = true;
632
633         if (!ignoringSpaces && style.collapseWhiteSpace() && previousCharacterIsSpace && isSpace)
634             ignoringSpaces = true;
635
636         if (ignoringSpaces && !isSpace)
637             ignoringSpaces = false;
638
639         // Ignore spaces and soft hyphens
640         if (ignoringSpaces) {
641             ASSERT(lastWordBoundary == i);
642             lastWordBoundary++;
643             continue;
644         } else if (c == softHyphen && style.hyphens() != HyphensNone) {
645             currMaxWidth += widthFromCache(f, lastWordBoundary, i - lastWordBoundary, leadWidth + currMaxWidth, &fallbackFonts, &glyphOverflow, style);
646             if (firstGlyphLeftOverflow < 0)
647                 firstGlyphLeftOverflow = glyphOverflow.left;
648             lastWordBoundary = i + 1;
649             continue;
650         }
651
652         bool hasBreak = breakAll || isBreakable(breakIterator, i, nextBreakable, breakNBSP);
653         bool betweenWords = true;
654         int j = i;
655         while (c != '\n' && !isSpaceAccordingToStyle(c, style) && c != '\t' && (c != softHyphen || style.hyphens() == HyphensNone)) {
656             j++;
657             if (j == len)
658                 break;
659             c = characterAt(j);
660             if (isBreakable(breakIterator, j, nextBreakable, breakNBSP) && characterAt(j - 1) != softHyphen)
661                 break;
662             if (breakAll) {
663                 betweenWords = false;
664                 break;
665             }
666         }
667
668         int wordLen = j - i;
669         if (wordLen) {
670             bool isSpace = (j < len) && isSpaceAccordingToStyle(c, style);
671             float w;
672             if (wordTrailingSpaceWidth && isSpace)
673                 w = widthFromCache(f, i, wordLen + 1, leadWidth + currMaxWidth, &fallbackFonts, &glyphOverflow, style) - wordTrailingSpaceWidth;
674             else {
675                 w = widthFromCache(f, i, wordLen, leadWidth + currMaxWidth, &fallbackFonts, &glyphOverflow, style);
676                 if (c == softHyphen && style.hyphens() != HyphensNone)
677                     currMinWidth += hyphenWidth(this, f);
678             }
679
680             if (w > maxWordWidth) {
681                 int suffixStart;
682                 float maxFragmentWidth = maxWordFragmentWidth(this, style, f, characters() + i, wordLen, minimumPrefixLength, minimumSuffixLength, suffixStart, fallbackFonts, glyphOverflow);
683
684                 if (suffixStart) {
685                     float suffixWidth;
686                     if (wordTrailingSpaceWidth && isSpace)
687                         suffixWidth = widthFromCache(f, i + suffixStart, wordLen - suffixStart + 1, leadWidth + currMaxWidth, 0, 0, style) - wordTrailingSpaceWidth;
688                     else
689                         suffixWidth = widthFromCache(f, i + suffixStart, wordLen - suffixStart, leadWidth + currMaxWidth, 0, 0, style);
690
691                     maxFragmentWidth = max(maxFragmentWidth, suffixWidth);
692
693                     currMinWidth += maxFragmentWidth - w;
694                     maxWordWidth = max(maxWordWidth, maxFragmentWidth);
695                 } else
696                     maxWordWidth = w;
697             }
698
699             if (firstGlyphLeftOverflow < 0)
700                 firstGlyphLeftOverflow = glyphOverflow.left;
701             currMinWidth += w;
702             if (betweenWords) {
703                 if (lastWordBoundary == i)
704                     currMaxWidth += w;
705                 else
706                     currMaxWidth += widthFromCache(f, lastWordBoundary, j - lastWordBoundary, leadWidth + currMaxWidth, &fallbackFonts, &glyphOverflow, style);
707                 lastWordBoundary = j;
708             }
709
710             bool isCollapsibleWhiteSpace = (j < len) && style.isCollapsibleWhiteSpace(c);
711             if (j < len && style.autoWrap())
712                 m_hasBreakableChar = true;
713
714             // Add in wordSpacing to our currMaxWidth, but not if this is the last word on a line or the
715             // last word in the run.
716             if (wordSpacing && (isSpace || isCollapsibleWhiteSpace) && !containsOnlyWhitespace(j, len-j))
717                 currMaxWidth += wordSpacing;
718
719             if (firstWord) {
720                 firstWord = false;
721                 // If the first character in the run is breakable, then we consider ourselves to have a beginning
722                 // minimum width of 0, since a break could occur right before our run starts, preventing us from ever
723                 // being appended to a previous text run when considering the total minimum width of the containing block.
724                 if (hasBreak)
725                     m_hasBreakableChar = true;
726                 m_beginMinWidth = hasBreak ? 0 : currMinWidth;
727             }
728             m_endMinWidth = currMinWidth;
729
730             if (currMinWidth > m_minWidth)
731                 m_minWidth = currMinWidth;
732             currMinWidth = 0;
733
734             i += wordLen - 1;
735         } else {
736             // Nowrap can never be broken, so don't bother setting the
737             // breakable character boolean. Pre can only be broken if we encounter a newline.
738             if (style.autoWrap() || isNewline)
739                 m_hasBreakableChar = true;
740
741             if (currMinWidth > m_minWidth)
742                 m_minWidth = currMinWidth;
743             currMinWidth = 0;
744
745             if (isNewline) { // Only set if preserveNewline was true and we saw a newline.
746                 if (firstLine) {
747                     firstLine = false;
748                     leadWidth = 0;
749                     if (!style.autoWrap())
750                         m_beginMinWidth = currMaxWidth;
751                 }
752
753                 if (currMaxWidth > m_maxWidth)
754                     m_maxWidth = currMaxWidth;
755                 currMaxWidth = 0;
756             } else {
757                 TextRun run = RenderBlock::constructTextRun(this, f, this, i, 1, style);
758                 run.setCharactersLength(len - i);
759                 ASSERT(run.charactersLength() >= run.length());
760                 run.setTabSize(!style.collapseWhiteSpace(), style.tabSize());
761                 run.setXPos(leadWidth + currMaxWidth);
762
763                 currMaxWidth += f.width(run, &fallbackFonts);
764                 glyphOverflow.right = 0;
765                 needsWordSpacing = isSpace && !previousCharacterIsSpace && i == len - 1;
766             }
767             ASSERT(lastWordBoundary == i);
768             lastWordBoundary++;
769         }
770     }
771
772     if (firstGlyphLeftOverflow > 0)
773         glyphOverflow.left = firstGlyphLeftOverflow;
774
775     if ((needsWordSpacing && len > 1) || (ignoringSpaces && !firstWord))
776         currMaxWidth += wordSpacing;
777
778     m_minWidth = max(currMinWidth, m_minWidth);
779     m_maxWidth = max(currMaxWidth, m_maxWidth);
780
781     if (!style.autoWrap())
782         m_minWidth = m_maxWidth;
783
784     if (style.whiteSpace() == PRE) {
785         if (firstLine)
786             m_beginMinWidth = m_maxWidth;
787         m_endMinWidth = currMaxWidth;
788     }
789
790     setPreferredLogicalWidthsDirty(false);
791 }
792
793 bool RenderText::isAllCollapsibleWhitespace() const
794 {
795     const RenderStyle& style = *this->style();
796     unsigned length = textLength();
797     if (is8Bit()) {
798         for (unsigned i = 0; i < length; ++i) {
799             if (!style.isCollapsibleWhiteSpace(characters8()[i]))
800                 return false;
801         }
802         return true;
803     }
804     for (unsigned i = 0; i < length; ++i) {
805         if (!style.isCollapsibleWhiteSpace(characters16()[i]))
806             return false;
807     }
808     return true;
809 }
810     
811 bool RenderText::containsOnlyWhitespace(unsigned from, unsigned len) const
812 {
813     ASSERT(m_text);
814     StringImpl& text = *m_text.impl();
815     unsigned currPos;
816     for (currPos = from;
817          currPos < from + len && (text[currPos] == '\n' || text[currPos] == ' ' || text[currPos] == '\t');
818          currPos++) { }
819     return currPos >= (from + len);
820 }
821
822 FloatPoint RenderText::firstRunOrigin() const
823 {
824     return IntPoint(firstRunX(), firstRunY());
825 }
826
827 float RenderText::firstRunX() const
828 {
829     return firstTextBox() ? firstTextBox()->x() : 0;
830 }
831
832 float RenderText::firstRunY() const
833 {
834     return firstTextBox() ? firstTextBox()->y() : 0;
835 }
836     
837 void RenderText::setSelectionState(SelectionState state)
838 {
839     RenderObject::setSelectionState(state);
840
841     if (canUpdateSelectionOnRootLineBoxes())
842         m_lineBoxes.setSelectionState(*this, state);
843
844     // The containing block can be null in case of an orphaned tree.
845     RenderBlock* containingBlock = this->containingBlock();
846     if (containingBlock && !containingBlock->isRenderView())
847         containingBlock->setSelectionState(state);
848 }
849
850 void RenderText::setTextWithOffset(const String& text, unsigned offset, unsigned len, bool force)
851 {
852     if (!force && m_text == text)
853         return;
854
855     int delta = text.length() - textLength();
856     unsigned end = len ? offset + len - 1 : offset;
857
858     m_linesDirty = m_lineBoxes.dirtyRange(*this, offset, end, delta);
859
860     setText(text, force || m_linesDirty);
861 }
862
863 void RenderText::transformText()
864 {
865     String textToTransform = originalText();
866     if (!textToTransform.isNull())
867         setText(textToTransform, true);
868 }
869
870 static inline bool isInlineFlowOrEmptyText(const RenderObject* o)
871 {
872     if (o->isRenderInline())
873         return true;
874     if (!o->isText())
875         return false;
876     StringImpl* text = toRenderText(o)->text();
877     if (!text)
878         return true;
879     return !text->length();
880 }
881
882 UChar RenderText::previousCharacter() const
883 {
884     // find previous text renderer if one exists
885     const RenderObject* previousText = this;
886     while ((previousText = previousText->previousInPreOrder()))
887         if (!isInlineFlowOrEmptyText(previousText))
888             break;
889     UChar prev = ' ';
890     if (previousText && previousText->isText())
891         if (StringImpl* previousString = toRenderText(previousText)->text())
892             prev = (*previousString)[previousString->length() - 1];
893     return prev;
894 }
895
896 void applyTextTransform(const RenderStyle* style, String& text, UChar previousCharacter)
897 {
898     if (!style)
899         return;
900
901     switch (style->textTransform()) {
902     case TTNONE:
903         break;
904     case CAPITALIZE:
905         makeCapitalized(&text, previousCharacter);
906         break;
907     case UPPERCASE:
908         text = text.upper(style->locale());
909         break;
910     case LOWERCASE:
911         text = text.lower(style->locale());
912         break;
913     }
914 }
915
916 void RenderText::setTextInternal(const String& text)
917 {
918     ASSERT(!text.isNull());
919     m_text = text;
920
921     if (m_useBackslashAsYenSymbol)
922         m_text.replace('\\', yenSign);
923
924     ASSERT(m_text);
925
926     if (style()) {
927         applyTextTransform(style(), m_text, previousCharacter());
928
929         // We use the same characters here as for list markers.
930         // See the listMarkerText function in RenderListMarker.cpp.
931         switch (style()->textSecurity()) {
932         case TSNONE:
933             break;
934         case TSCIRCLE:
935             secureText(whiteBullet);
936             break;
937         case TSDISC:
938             secureText(bullet);
939             break;
940         case TSSQUARE:
941             secureText(blackSquare);
942         }
943     }
944
945     ASSERT(!m_text.isNull());
946
947     m_isAllASCII = m_text.containsOnlyASCII();
948     m_canUseSimpleFontCodePath = computeCanUseSimpleFontCodePath();
949 }
950
951 void RenderText::secureText(UChar mask)
952 {
953     if (!textLength())
954         return;
955
956     int lastTypedCharacterOffsetToReveal = -1;
957     String revealedText;
958     SecureTextTimer* secureTextTimer = gSecureTextTimers ? gSecureTextTimers->get(this) : 0;
959     if (secureTextTimer && secureTextTimer->isActive()) {
960         lastTypedCharacterOffsetToReveal = secureTextTimer->lastTypedCharacterOffset();
961         if (lastTypedCharacterOffsetToReveal >= 0)
962             revealedText.append(m_text[lastTypedCharacterOffsetToReveal]);
963     }
964
965     m_text.fill(mask);
966     if (lastTypedCharacterOffsetToReveal >= 0) {
967         m_text.replace(lastTypedCharacterOffsetToReveal, 1, revealedText);
968         // m_text may be updated later before timer fires. We invalidate the lastTypedCharacterOffset to avoid inconsistency.
969         secureTextTimer->invalidate();
970     }
971 }
972
973 void RenderText::setText(const String& text, bool force)
974 {
975     ASSERT(!text.isNull());
976
977     if (!force && m_text == text)
978         return;
979
980     setTextInternal(text);
981     setNeedsLayoutAndPrefWidthsRecalc();
982     m_knownToHaveNoOverflowAndNoFallbackFonts = false;
983     
984     if (AXObjectCache* cache = document().existingAXObjectCache())
985         cache->textChanged(this);
986 }
987
988 String RenderText::textWithoutConvertingBackslashToYenSymbol() const
989 {
990     if (!m_useBackslashAsYenSymbol || style()->textSecurity() != TSNONE)
991         return text();
992
993     String text = originalText();
994     applyTextTransform(style(), text, previousCharacter());
995     return text;
996 }
997
998 void RenderText::dirtyLineBoxes(bool fullLayout)
999 {
1000     if (fullLayout)
1001         m_lineBoxes.deleteAll(*this);
1002     else if (!m_linesDirty)
1003         m_lineBoxes.dirtyAll();
1004     m_linesDirty = false;
1005 }
1006
1007 InlineTextBox* RenderText::createTextBox()
1008 {
1009     return new (renderArena()) InlineTextBox(*this);
1010 }
1011
1012 void RenderText::positionLineBox(InlineBox* box)
1013 {
1014     InlineTextBox* textBox = toInlineTextBox(box);
1015
1016     // FIXME: should not be needed!!!
1017     if (!textBox->len()) {
1018         // We want the box to be destroyed.
1019         textBox->removeFromParent();
1020         m_lineBoxes.remove(*textBox);
1021         textBox->destroy(renderArena());
1022         return;
1023     }
1024
1025     m_containsReversedText |= !textBox->isLeftToRightDirection();
1026 }
1027
1028 float RenderText::width(unsigned from, unsigned len, float xPos, bool firstLine, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
1029 {
1030     if (from >= textLength())
1031         return 0;
1032
1033     if (from + len > textLength())
1034         len = textLength() - from;
1035
1036     const RenderStyle& lineStyle = firstLine ? *firstLineStyle() : *style();
1037     return width(from, len, lineStyle.font(), xPos, fallbackFonts, glyphOverflow);
1038 }
1039
1040 float RenderText::width(unsigned from, unsigned len, const Font& f, float xPos, HashSet<const SimpleFontData*>* fallbackFonts, GlyphOverflow* glyphOverflow) const
1041 {
1042     ASSERT(from + len <= textLength());
1043     if (!textLength())
1044         return 0;
1045
1046     const RenderStyle& style = *this->style();
1047     float w;
1048     if (&f == &style.font()) {
1049         if (!style.preserveNewline() && !from && len == textLength() && (!glyphOverflow || !glyphOverflow->computeBounds)) {
1050             if (fallbackFonts) {
1051                 ASSERT(glyphOverflow);
1052                 if (preferredLogicalWidthsDirty() || !m_knownToHaveNoOverflowAndNoFallbackFonts) {
1053                     const_cast<RenderText*>(this)->computePreferredLogicalWidths(0, *fallbackFonts, *glyphOverflow);
1054                     if (fallbackFonts->isEmpty() && !glyphOverflow->left && !glyphOverflow->right && !glyphOverflow->top && !glyphOverflow->bottom)
1055                         m_knownToHaveNoOverflowAndNoFallbackFonts = true;
1056                 }
1057                 w = m_maxWidth;
1058             } else
1059                 w = maxLogicalWidth();
1060         } else
1061             w = widthFromCache(f, from, len, xPos, fallbackFonts, glyphOverflow, style);
1062     } else {
1063         TextRun run = RenderBlock::constructTextRun(const_cast<RenderText*>(this), f, this, from, len, style);
1064         run.setCharactersLength(textLength() - from);
1065         ASSERT(run.charactersLength() >= run.length());
1066
1067         run.setCharacterScanForCodePath(!canUseSimpleFontCodePath());
1068         run.setTabSize(!style.collapseWhiteSpace(), style.tabSize());
1069         run.setXPos(xPos);
1070         w = f.width(run, fallbackFonts, glyphOverflow);
1071     }
1072
1073     return w;
1074 }
1075
1076 IntRect RenderText::linesBoundingBox() const
1077 {
1078     return m_lineBoxes.boundingBox(*this);
1079 }
1080
1081 LayoutRect RenderText::linesVisualOverflowBoundingBox() const
1082 {
1083     return m_lineBoxes.visualOverflowBoundingBox(*this);
1084 }
1085
1086 LayoutRect RenderText::clippedOverflowRectForRepaint(const RenderLayerModelObject* repaintContainer) const
1087 {
1088     RenderObject* rendererToRepaint = containingBlock();
1089
1090     // Do not cross self-painting layer boundaries.
1091     RenderObject& enclosingLayerRenderer = enclosingLayer()->renderer();
1092     if (&enclosingLayerRenderer != rendererToRepaint && !rendererToRepaint->isDescendantOf(&enclosingLayerRenderer))
1093         rendererToRepaint = &enclosingLayerRenderer;
1094
1095     // The renderer we chose to repaint may be an ancestor of repaintContainer, but we need to do a repaintContainer-relative repaint.
1096     if (repaintContainer && repaintContainer != rendererToRepaint && !rendererToRepaint->isDescendantOf(repaintContainer))
1097         return repaintContainer->clippedOverflowRectForRepaint(repaintContainer);
1098
1099     return rendererToRepaint->clippedOverflowRectForRepaint(repaintContainer);
1100 }
1101
1102 LayoutRect RenderText::selectionRectForRepaint(const RenderLayerModelObject* repaintContainer, bool clipToVisibleContent)
1103 {
1104     ASSERT(!needsLayout());
1105
1106     if (selectionState() == SelectionNone)
1107         return LayoutRect();
1108     RenderBlock* cb = containingBlock();
1109     if (!cb)
1110         return LayoutRect();
1111
1112     // Now calculate startPos and endPos for painting selection.
1113     // We include a selection while endPos > 0
1114     int startPos, endPos;
1115     if (selectionState() == SelectionInside) {
1116         // We are fully selected.
1117         startPos = 0;
1118         endPos = textLength();
1119     } else {
1120         selectionStartEnd(startPos, endPos);
1121         if (selectionState() == SelectionStart)
1122             endPos = textLength();
1123         else if (selectionState() == SelectionEnd)
1124             startPos = 0;
1125     }
1126
1127     if (startPos == endPos)
1128         return IntRect();
1129
1130     LayoutRect rect = m_lineBoxes.selectionRectForRange(startPos, endPos);
1131
1132     if (clipToVisibleContent)
1133         computeRectForRepaint(repaintContainer, rect);
1134     else {
1135         if (cb->hasColumns())
1136             cb->adjustRectForColumns(rect);
1137
1138         rect = localToContainerQuad(FloatRect(rect), repaintContainer).enclosingBoundingBox();
1139     }
1140
1141     return rect;
1142 }
1143
1144 int RenderText::caretMinOffset() const
1145 {
1146     return m_lineBoxes.caretMinOffset();
1147 }
1148
1149 int RenderText::caretMaxOffset() const
1150 {
1151     return m_lineBoxes.caretMaxOffset(*this);
1152 }
1153
1154 bool RenderText::containsCharacterOffset(unsigned offset) const
1155 {
1156     return m_lineBoxes.containsOffset(*this, offset, RenderTextLineBoxes::CharacterOffset);
1157 }
1158
1159 bool RenderText::containsCaretOffset(unsigned offset) const
1160 {
1161     return m_lineBoxes.containsOffset(*this, offset, RenderTextLineBoxes::CaretOffset);
1162 }
1163
1164 bool RenderText::hasRenderedText() const
1165 {
1166     return m_lineBoxes.hasRenderedText();
1167 }
1168
1169 int RenderText::previousOffset(int current) const
1170 {
1171     if (isAllASCII() || m_text.is8Bit())
1172         return current - 1;
1173
1174     StringImpl* textImpl = m_text.impl();
1175     TextBreakIterator* iterator = cursorMovementIterator(textImpl->characters16(), textImpl->length());
1176     if (!iterator)
1177         return current - 1;
1178
1179     long result = textBreakPreceding(iterator, current);
1180     if (result == TextBreakDone)
1181         result = current - 1;
1182
1183
1184     return result;
1185 }
1186
1187 #if PLATFORM(MAC) || PLATFORM(EFL)
1188
1189 #define HANGUL_CHOSEONG_START (0x1100)
1190 #define HANGUL_CHOSEONG_END (0x115F)
1191 #define HANGUL_JUNGSEONG_START (0x1160)
1192 #define HANGUL_JUNGSEONG_END (0x11A2)
1193 #define HANGUL_JONGSEONG_START (0x11A8)
1194 #define HANGUL_JONGSEONG_END (0x11F9)
1195 #define HANGUL_SYLLABLE_START (0xAC00)
1196 #define HANGUL_SYLLABLE_END (0xD7AF)
1197 #define HANGUL_JONGSEONG_COUNT (28)
1198
1199 enum HangulState {
1200     HangulStateL,
1201     HangulStateV,
1202     HangulStateT,
1203     HangulStateLV,
1204     HangulStateLVT,
1205     HangulStateBreak
1206 };
1207
1208 inline bool isHangulLVT(UChar32 character)
1209 {
1210     return (character - HANGUL_SYLLABLE_START) % HANGUL_JONGSEONG_COUNT;
1211 }
1212
1213 inline bool isMark(UChar32 c)
1214 {
1215     int8_t charType = u_charType(c);
1216     return charType == U_NON_SPACING_MARK || charType == U_ENCLOSING_MARK || charType == U_COMBINING_SPACING_MARK;
1217 }
1218
1219 inline bool isRegionalIndicator(UChar32 c)
1220 {
1221     // National flag emoji each consists of a pair of regional indicator symbols.
1222     return 0x1F1E6 <= c && c <= 0x1F1FF;
1223 }
1224
1225 #endif
1226
1227 int RenderText::previousOffsetForBackwardDeletion(int current) const
1228 {
1229 #if PLATFORM(MAC) || PLATFORM(EFL)
1230     ASSERT(m_text);
1231     StringImpl& text = *m_text.impl();
1232     UChar32 character;
1233     bool sawRegionalIndicator = false;
1234     while (current > 0) {
1235         if (U16_IS_TRAIL(text[--current]))
1236             --current;
1237         if (current < 0)
1238             break;
1239
1240         UChar32 character = text.characterStartingAt(current);
1241
1242         if (sawRegionalIndicator) {
1243             // We don't check if the pair of regional indicator symbols before current position can actually be combined
1244             // into a flag, and just delete it. This may not agree with how the pair is rendered in edge cases,
1245             // but is good enough in practice.
1246             if (isRegionalIndicator(character))
1247                 break;
1248             // Don't delete a preceding character that isn't a regional indicator symbol.
1249             U16_FWD_1_UNSAFE(text, current);
1250         }
1251
1252         // We don't combine characters in Armenian ... Limbu range for backward deletion.
1253         if ((character >= 0x0530) && (character < 0x1950))
1254             break;
1255
1256         if (isRegionalIndicator(character)) {
1257             sawRegionalIndicator = true;
1258             continue;
1259         }
1260
1261         if (!isMark(character) && (character != 0xFF9E) && (character != 0xFF9F))
1262             break;
1263     }
1264
1265     if (current <= 0)
1266         return current;
1267
1268     // Hangul
1269     character = text.characterStartingAt(current);
1270     if (((character >= HANGUL_CHOSEONG_START) && (character <= HANGUL_JONGSEONG_END)) || ((character >= HANGUL_SYLLABLE_START) && (character <= HANGUL_SYLLABLE_END))) {
1271         HangulState state;
1272
1273         if (character < HANGUL_JUNGSEONG_START)
1274             state = HangulStateL;
1275         else if (character < HANGUL_JONGSEONG_START)
1276             state = HangulStateV;
1277         else if (character < HANGUL_SYLLABLE_START)
1278             state = HangulStateT;
1279         else
1280             state = isHangulLVT(character) ? HangulStateLVT : HangulStateLV;
1281
1282         while (current > 0 && ((character = text.characterStartingAt(current - 1)) >= HANGUL_CHOSEONG_START) && (character <= HANGUL_SYLLABLE_END) && ((character <= HANGUL_JONGSEONG_END) || (character >= HANGUL_SYLLABLE_START))) {
1283             switch (state) {
1284             case HangulStateV:
1285                 if (character <= HANGUL_CHOSEONG_END)
1286                     state = HangulStateL;
1287                 else if ((character >= HANGUL_SYLLABLE_START) && (character <= HANGUL_SYLLABLE_END) && !isHangulLVT(character))
1288                     state = HangulStateLV;
1289                 else if (character > HANGUL_JUNGSEONG_END)
1290                     state = HangulStateBreak;
1291                 break;
1292             case HangulStateT:
1293                 if ((character >= HANGUL_JUNGSEONG_START) && (character <= HANGUL_JUNGSEONG_END))
1294                     state = HangulStateV;
1295                 else if ((character >= HANGUL_SYLLABLE_START) && (character <= HANGUL_SYLLABLE_END))
1296                     state = (isHangulLVT(character) ? HangulStateLVT : HangulStateLV);
1297                 else if (character < HANGUL_JUNGSEONG_START)
1298                     state = HangulStateBreak;
1299                 break;
1300             default:
1301                 state = (character < HANGUL_JUNGSEONG_START) ? HangulStateL : HangulStateBreak;
1302                 break;
1303             }
1304             if (state == HangulStateBreak)
1305                 break;
1306
1307             --current;
1308         }
1309     }
1310
1311     return current;
1312 #else
1313     // Platforms other than Mac delete by one code point.
1314     if (U16_IS_TRAIL(m_text[--current]))
1315         --current;
1316     if (current < 0)
1317         current = 0;
1318     return current;
1319 #endif
1320 }
1321
1322 int RenderText::nextOffset(int current) const
1323 {
1324     if (isAllASCII() || m_text.is8Bit())
1325         return current + 1;
1326
1327     StringImpl* textImpl = m_text.impl();
1328     TextBreakIterator* iterator = cursorMovementIterator(textImpl->characters16(), textImpl->length());
1329     if (!iterator)
1330         return current + 1;
1331
1332     long result = textBreakFollowing(iterator, current);
1333     if (result == TextBreakDone)
1334         result = current + 1;
1335
1336     return result;
1337 }
1338
1339 bool RenderText::computeCanUseSimpleFontCodePath() const
1340 {
1341     if (isAllASCII() || m_text.is8Bit())
1342         return true;
1343     return Font::characterRangeCodePath(characters(), length()) == Font::Simple;
1344 }
1345
1346 void RenderText::momentarilyRevealLastTypedCharacter(unsigned lastTypedCharacterOffset)
1347 {
1348     if (!gSecureTextTimers)
1349         gSecureTextTimers = new SecureTextTimerMap;
1350
1351     SecureTextTimer* secureTextTimer = gSecureTextTimers->get(this);
1352     if (!secureTextTimer) {
1353         secureTextTimer = new SecureTextTimer(this);
1354         gSecureTextTimers->add(this, secureTextTimer);
1355     }
1356     secureTextTimer->restartWithNewText(lastTypedCharacterOffset);
1357 }
1358
1359 } // namespace WebCore