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