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