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