Crash when changing video subtitles.
[WebKit-https.git] / Source / WebCore / html / track / VTTCue.cpp
1 /*
2  * Copyright (C) 2011, 2013 Google Inc.  All rights reserved.
3  * Copyright (C) 2011-2014 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "config.h"
33
34 #if ENABLE(VIDEO_TRACK)
35 #include "VTTCue.h"
36
37 #include "CSSPropertyNames.h"
38 #include "CSSValueKeywords.h"
39 #include "DocumentFragment.h"
40 #include "Event.h"
41 #include "ExceptionCode.h"
42 #include "HTMLDivElement.h"
43 #include "HTMLSpanElement.h"
44 #include "Logging.h"
45 #include "NodeTraversal.h"
46 #include "RenderVTTCue.h"
47 #include "Text.h"
48 #include "TextTrack.h"
49 #include "TextTrackCueList.h"
50 #include "VTTRegionList.h"
51 #include "VTTScanner.h"
52 #include "WebVTTElement.h"
53 #include "WebVTTParser.h"
54 #include <wtf/MathExtras.h>
55 #include <wtf/text/StringBuilder.h>
56
57 namespace WebCore {
58
59 // This constant should correspond with the percentage returned by CaptionUserPreferences::captionFontSizeScaleAndImportance.
60 const static double DEFAULTCAPTIONFONTSIZEPERCENTAGE = 5;
61
62 static const int undefinedPosition = -1;
63
64 static const CSSValueID displayWritingModeMap[] = {
65     CSSValueHorizontalTb, CSSValueVerticalRl, CSSValueVerticalLr
66 };
67 COMPILE_ASSERT(WTF_ARRAY_LENGTH(displayWritingModeMap) == VTTCue::NumberOfWritingDirections, displayWritingModeMap_has_wrong_size);
68
69 static const CSSValueID displayAlignmentMap[] = {
70     CSSValueStart, CSSValueCenter, CSSValueEnd, CSSValueLeft, CSSValueRight
71 };
72 COMPILE_ASSERT(WTF_ARRAY_LENGTH(displayAlignmentMap) == VTTCue::NumberOfAlignments, displayAlignmentMap_has_wrong_size);
73
74 static const String& startKeyword()
75 {
76     static NeverDestroyed<const String> start(ASCIILiteral("start"));
77     return start;
78 }
79
80 static const String& middleKeyword()
81 {
82     static NeverDestroyed<const String> middle(ASCIILiteral("middle"));
83     return middle;
84 }
85
86 static const String& endKeyword()
87 {
88     static NeverDestroyed<const String> end(ASCIILiteral("end"));
89     return end;
90 }
91
92 static const String& leftKeyword()
93 {
94     static NeverDestroyed<const String> left("left");
95     return left;
96 }
97
98 static const String& rightKeyword()
99 {
100     static NeverDestroyed<const String> right("right");
101     return right;
102 }
103
104 static const String& horizontalKeyword()
105 {
106     return emptyString();
107 }
108
109 static const String& verticalGrowingLeftKeyword()
110 {
111     static NeverDestroyed<const String> verticalrl(ASCIILiteral("rl"));
112     return verticalrl;
113 }
114
115 static const String& verticalGrowingRightKeyword()
116 {
117     static NeverDestroyed<const String> verticallr(ASCIILiteral("lr"));
118     return verticallr;
119 }
120
121 // ----------------------------
122
123 Ref<VTTCueBox> VTTCueBox::create(Document& document, VTTCue& cue)
124 {
125     VTTCueBox& cueBox = *new VTTCueBox(document, cue);
126     cueBox.setPseudo(VTTCueBox::vttCueBoxShadowPseudoId());
127     return adoptRef(cueBox);
128 }
129
130 VTTCueBox::VTTCueBox(Document& document, VTTCue& cue)
131     : HTMLElement(divTag, document)
132     , m_cue(cue)
133 {
134     setPseudo(vttCueBoxShadowPseudoId());
135 }
136
137 VTTCue* VTTCueBox::getCue() const
138 {
139     return &m_cue;
140 }
141
142 void VTTCueBox::applyCSSProperties(const IntSize& videoSize)
143 {
144     // FIXME: Apply all the initial CSS positioning properties. http://wkb.ug/79916
145     if (!m_cue.regionId().isEmpty()) {
146         setInlineStyleProperty(CSSPropertyPosition, CSSValueRelative);
147         return;
148     }
149
150     // 3.5.1 On the (root) List of WebVTT Node Objects:
151
152     // the 'position' property must be set to 'absolute'
153     setInlineStyleProperty(CSSPropertyPosition, CSSValueAbsolute);
154
155     //  the 'unicode-bidi' property must be set to 'plaintext'
156     setInlineStyleProperty(CSSPropertyUnicodeBidi, CSSValueWebkitPlaintext);
157
158     // the 'direction' property must be set to direction
159     setInlineStyleProperty(CSSPropertyDirection, m_cue.getCSSWritingDirection());
160
161     // the 'writing-mode' property must be set to writing-mode
162     setInlineStyleProperty(CSSPropertyWritingMode, m_cue.getCSSWritingMode(), false);
163
164     std::pair<float, float> position = m_cue.getCSSPosition();
165
166     // the 'top' property must be set to top,
167     setInlineStyleProperty(CSSPropertyTop, static_cast<double>(position.second), CSSPrimitiveValue::CSS_PERCENTAGE);
168
169     // the 'left' property must be set to left
170     setInlineStyleProperty(CSSPropertyLeft, static_cast<double>(position.first), CSSPrimitiveValue::CSS_PERCENTAGE);
171
172     double authorFontSize = std::min(videoSize.width(), videoSize.height()) * DEFAULTCAPTIONFONTSIZEPERCENTAGE / 100.0;
173     double multiplier = 1.0;
174     if (authorFontSize)
175         multiplier = m_fontSizeFromCaptionUserPrefs / authorFontSize;
176
177     double textPosition = m_cue.position();
178     double maxSize = 100.0;
179     CSSValueID alignment = m_cue.getCSSAlignment();
180     if (alignment == CSSValueEnd || alignment == CSSValueRight)
181         maxSize = textPosition;
182     else if (alignment == CSSValueStart || alignment == CSSValueLeft)
183         maxSize = 100.0 - textPosition;
184
185     double newCueSize = std::min(m_cue.getCSSSize() * multiplier, 100.0);
186     // the 'width' property must be set to width, and the 'height' property  must be set to height
187     if (m_cue.vertical() == horizontalKeyword()) {
188         setInlineStyleProperty(CSSPropertyWidth, newCueSize, CSSPrimitiveValue::CSS_PERCENTAGE);
189         setInlineStyleProperty(CSSPropertyHeight, CSSValueAuto);
190         setInlineStyleProperty(CSSPropertyMinWidth, "-webkit-min-content");
191         setInlineStyleProperty(CSSPropertyMaxWidth, maxSize, CSSPrimitiveValue::CSS_PERCENTAGE);
192         if ((alignment == CSSValueMiddle || alignment == CSSValueCenter) && multiplier != 1.0)
193             setInlineStyleProperty(CSSPropertyLeft, static_cast<double>(position.first - (newCueSize - m_cue.getCSSSize()) / 2), CSSPrimitiveValue::CSS_PERCENTAGE);
194     } else {
195         setInlineStyleProperty(CSSPropertyWidth, CSSValueAuto);
196         setInlineStyleProperty(CSSPropertyHeight, newCueSize, CSSPrimitiveValue::CSS_PERCENTAGE);
197         setInlineStyleProperty(CSSPropertyMinHeight, "-webkit-min-content");
198         setInlineStyleProperty(CSSPropertyMaxHeight, maxSize, CSSPrimitiveValue::CSS_PERCENTAGE);
199         if ((alignment == CSSValueMiddle || alignment == CSSValueCenter) && multiplier != 1.0)
200             setInlineStyleProperty(CSSPropertyTop, static_cast<double>(position.second - (newCueSize - m_cue.getCSSSize()) / 2), CSSPrimitiveValue::CSS_PERCENTAGE);
201     }
202
203     // The 'text-align' property on the (root) List of WebVTT Node Objects must
204     // be set to the value in the second cell of the row of the table below
205     // whose first cell is the value of the corresponding cue's text track cue
206     // alignment:
207     setInlineStyleProperty(CSSPropertyTextAlign, m_cue.getCSSAlignment());
208     
209     if (!m_cue.snapToLines()) {
210         // 10.13.1 Set up x and y:
211         // Note: x and y are set through the CSS left and top above.
212
213         // 10.13.2 Position the boxes in boxes such that the point x% along the
214         // width of the bounding box of the boxes in boxes is x% of the way
215         // across the width of the video's rendering area, and the point y%
216         // along the height of the bounding box of the boxes in boxes is y%
217         // of the way across the height of the video's rendering area, while
218         // maintaining the relative positions of the boxes in boxes to each
219         // other.
220         setInlineStyleProperty(CSSPropertyTransform,
221             String::format("translate(-%.2f%%, -%.2f%%)", position.first, position.second));
222
223         setInlineStyleProperty(CSSPropertyWhiteSpace, CSSValuePre);
224     }
225 }
226
227 const AtomicString& VTTCueBox::vttCueBoxShadowPseudoId()
228 {
229     static NeverDestroyed<const AtomicString> trackDisplayBoxShadowPseudoId("-webkit-media-text-track-display", AtomicString::ConstructFromLiteral);
230     return trackDisplayBoxShadowPseudoId;
231 }
232
233 RenderPtr<RenderElement> VTTCueBox::createElementRenderer(RenderStyle&& style, const RenderTreePosition&)
234 {
235     return createRenderer<RenderVTTCue>(*this, WTFMove(style));
236 }
237
238 // ----------------------------
239
240 const AtomicString& VTTCue::cueBackdropShadowPseudoId()
241 {
242     static NeverDestroyed<const AtomicString> cueBackdropShadowPseudoId("-webkit-media-text-track-display-backdrop", AtomicString::ConstructFromLiteral);
243     return cueBackdropShadowPseudoId;
244 }
245
246 Ref<VTTCue> VTTCue::create(ScriptExecutionContext& context, const WebVTTCueData& data)
247 {
248     return adoptRef(*new VTTCue(context, data));
249 }
250
251 VTTCue::VTTCue(ScriptExecutionContext& context, const MediaTime& start, const MediaTime& end, const String& content)
252     : TextTrackCue(context, start, end)
253     , m_content(content)
254 {
255     initialize(context);
256 }
257
258 VTTCue::VTTCue(ScriptExecutionContext& context, const WebVTTCueData& cueData)
259     : TextTrackCue(context, MediaTime::zeroTime(), MediaTime::zeroTime())
260 {
261     initialize(context);
262     setText(cueData.content());
263     setStartTime(cueData.startTime());
264     setEndTime(cueData.endTime());
265     setId(cueData.id());
266     setCueSettings(cueData.settings());
267     m_originalStartTime = cueData.originalStartTime();
268 }
269
270 VTTCue::~VTTCue()
271 {
272     // FIXME: We should set m_cue in VTTCueBox to nullptr instead.
273     if (m_displayTree && m_displayTree->document().refCount())
274         m_displayTree->remove();
275 }
276
277 void VTTCue::initialize(ScriptExecutionContext& context)
278 {
279     m_linePosition = undefinedPosition;
280     m_computedLinePosition = undefinedPosition;
281     m_textPosition = 50;
282     m_cueSize = 100;
283     m_writingDirection = Horizontal;
284     m_cueAlignment = Middle;
285     m_webVTTNodeTree = nullptr;
286     m_cueBackdropBox = HTMLDivElement::create(downcast<Document>(context));
287     m_cueHighlightBox = HTMLSpanElement::create(spanTag, downcast<Document>(context));
288     m_displayDirection = CSSValueLtr;
289     m_displaySize = 0;
290     m_snapToLines = true;
291     m_displayTreeShouldChange = true;
292     m_notifyRegion = true;
293     m_originalStartTime = MediaTime::zeroTime();
294 }
295
296 Ref<VTTCueBox> VTTCue::createDisplayTree()
297 {
298     return VTTCueBox::create(ownerDocument(), *this);
299 }
300
301 VTTCueBox& VTTCue::displayTreeInternal()
302 {
303     if (!m_displayTree)
304         m_displayTree = createDisplayTree();
305     return *m_displayTree;
306 }
307
308 void VTTCue::didChange()
309 {
310     TextTrackCue::didChange();
311     m_displayTreeShouldChange = true;
312 }
313
314 const String& VTTCue::vertical() const
315 {
316     switch (m_writingDirection) {
317     case Horizontal: 
318         return horizontalKeyword();
319     case VerticalGrowingLeft:
320         return verticalGrowingLeftKeyword();
321     case VerticalGrowingRight:
322         return verticalGrowingRightKeyword();
323     default:
324         ASSERT_NOT_REACHED();
325         return emptyString();
326     }
327 }
328
329 ExceptionOr<void> VTTCue::setVertical(const String& value)
330 {
331     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-vertical
332     // On setting, the text track cue writing direction must be set to the value given 
333     // in the first cell of the row in the table above whose second cell is a 
334     // case-sensitive match for the new value, if any. If none of the values match, then
335     // the user agent must instead throw a SyntaxError exception.
336     
337     WritingDirection direction = m_writingDirection;
338     if (value == horizontalKeyword())
339         direction = Horizontal;
340     else if (value == verticalGrowingLeftKeyword())
341         direction = VerticalGrowingLeft;
342     else if (value == verticalGrowingRightKeyword())
343         direction = VerticalGrowingRight;
344     else
345         return Exception { SYNTAX_ERR };
346     
347     if (direction == m_writingDirection)
348         return { };
349
350     willChange();
351     m_writingDirection = direction;
352     didChange();
353
354     return { };
355 }
356
357 void VTTCue::setSnapToLines(bool value)
358 {
359     if (m_snapToLines == value)
360         return;
361     
362     willChange();
363     m_snapToLines = value;
364     didChange();
365 }
366
367 ExceptionOr<void> VTTCue::setLine(double position)
368 {
369     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-line
370     // On setting, if the text track cue snap-to-lines flag is not set, and the new
371     // value is negative or greater than 100, then throw an IndexSizeError exception.
372     if (!m_snapToLines && !(position >= 0 && position <= 100))
373         return Exception { INDEX_SIZE_ERR };
374
375     // Otherwise, set the text track cue line position to the new value.
376     if (m_linePosition == position)
377         return { };
378
379     willChange();
380     m_linePosition = position;
381     m_computedLinePosition = calculateComputedLinePosition();
382     didChange();
383
384     return { };
385 }
386
387 ExceptionOr<void> VTTCue::setPosition(double position)
388 {
389     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-position
390     // On setting, if the new value is negative or greater than 100, then throw an IndexSizeError exception.
391     // Otherwise, set the text track cue text position to the new value.
392     if (!(position >= 0 && position <= 100))
393         return Exception { INDEX_SIZE_ERR };
394
395     // Otherwise, set the text track cue line position to the new value.
396     if (m_textPosition == position)
397         return { };
398     
399     willChange();
400     m_textPosition = position;
401     didChange();
402
403     return { };
404 }
405
406 ExceptionOr<void> VTTCue::setSize(int size)
407 {
408     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-size
409     // On setting, if the new value is negative or greater than 100, then throw an IndexSizeError
410     // exception. Otherwise, set the text track cue size to the new value.
411     if (!(size >= 0 && size <= 100))
412         return Exception { INDEX_SIZE_ERR };
413
414     // Otherwise, set the text track cue line position to the new value.
415     if (m_cueSize == size)
416         return { };
417     
418     willChange();
419     m_cueSize = size;
420     didChange();
421
422     return { };
423 }
424
425 const String& VTTCue::align() const
426 {
427     switch (m_cueAlignment) {
428     case Start:
429         return startKeyword();
430     case Middle:
431         return middleKeyword();
432     case End:
433         return endKeyword();
434     case Left:
435         return leftKeyword();
436     case Right:
437         return rightKeyword();
438     default:
439         ASSERT_NOT_REACHED();
440         return emptyString();
441     }
442 }
443
444 ExceptionOr<void> VTTCue::setAlign(const String& value)
445 {
446     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-align
447     // On setting, the text track cue alignment must be set to the value given in the 
448     // first cell of the row in the table above whose second cell is a case-sensitive
449     // match for the new value, if any. If none of the values match, then the user
450     // agent must instead throw a SyntaxError exception.
451     
452     CueAlignment alignment;
453     if (value == startKeyword())
454         alignment = Start;
455     else if (value == middleKeyword())
456         alignment = Middle;
457     else if (value == endKeyword())
458         alignment = End;
459     else if (value == leftKeyword())
460         alignment = Left;
461     else if (value == rightKeyword())
462         alignment = Right;
463     else
464         return Exception { SYNTAX_ERR };
465     
466     if (alignment == m_cueAlignment)
467         return { };
468
469     willChange();
470     m_cueAlignment = alignment;
471     didChange();
472
473     return { };
474 }
475     
476 void VTTCue::setText(const String& text)
477 {
478     if (m_content == text)
479         return;
480     
481     willChange();
482     // Clear the document fragment but don't bother to create it again just yet as we can do that
483     // when it is requested.
484     m_webVTTNodeTree = nullptr;
485     m_content = text;
486     didChange();
487 }
488
489 void VTTCue::createWebVTTNodeTree()
490 {
491     if (!m_webVTTNodeTree)
492         m_webVTTNodeTree = WebVTTParser::createDocumentFragmentFromCueText(ownerDocument(), m_content);
493 }
494
495 void VTTCue::copyWebVTTNodeToDOMTree(ContainerNode* webVTTNode, ContainerNode* parent)
496 {
497     for (Node* node = webVTTNode->firstChild(); node; node = node->nextSibling()) {
498         RefPtr<Node> clonedNode;
499         if (is<WebVTTElement>(*node))
500             clonedNode = downcast<WebVTTElement>(*node).createEquivalentHTMLElement(ownerDocument());
501         else
502             clonedNode = node->cloneNode(false);
503         parent->appendChild(*clonedNode);
504         if (is<ContainerNode>(*node))
505             copyWebVTTNodeToDOMTree(downcast<ContainerNode>(node), downcast<ContainerNode>(clonedNode.get()));
506     }
507 }
508
509 RefPtr<DocumentFragment> VTTCue::getCueAsHTML()
510 {
511     createWebVTTNodeTree();
512     if (!m_webVTTNodeTree)
513         return nullptr;
514
515     auto clonedFragment = DocumentFragment::create(ownerDocument());
516     copyWebVTTNodeToDOMTree(m_webVTTNodeTree.get(), clonedFragment.ptr());
517     return WTFMove(clonedFragment);
518 }
519
520 RefPtr<DocumentFragment> VTTCue::createCueRenderingTree()
521 {
522     createWebVTTNodeTree();
523     if (!m_webVTTNodeTree)
524         return nullptr;
525
526     auto clonedFragment = DocumentFragment::create(ownerDocument());
527     m_webVTTNodeTree->cloneChildNodes(clonedFragment);
528     return WTFMove(clonedFragment);
529 }
530
531 void VTTCue::setRegionId(const String& regionId)
532 {
533     if (m_regionId == regionId)
534         return;
535
536     willChange();
537     m_regionId = regionId;
538     didChange();
539 }
540
541 void VTTCue::notifyRegionWhenRemovingDisplayTree(bool notifyRegion)
542 {
543     m_notifyRegion = notifyRegion;
544 }
545
546 void VTTCue::setIsActive(bool active)
547 {
548     TextTrackCue::setIsActive(active);
549
550     if (!active) {
551         if (!hasDisplayTree())
552             return;
553
554         // Remove the display tree as soon as the cue becomes inactive.
555         removeDisplayTree();
556     }
557 }
558
559 int VTTCue::calculateComputedLinePosition()
560 {
561     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#text-track-cue-computed-line-position
562
563     // If the text track cue line position is numeric, then that is the text
564     // track cue computed line position.
565     if (m_linePosition != undefinedPosition)
566         return m_linePosition;
567
568     // If the text track cue snap-to-lines flag of the text track cue is not
569     // set, the text track cue computed line position is the value 100;
570     if (!m_snapToLines)
571         return 100;
572
573     // Otherwise, it is the value returned by the following algorithm:
574
575     // If cue is not associated with a text track, return -1 and abort these
576     // steps.
577     if (!track())
578         return -1;
579
580     // Let n be the number of text tracks whose text track mode is showing or
581     // showing by default and that are in the media element's list of text
582     // tracks before track.
583     int n = track()->trackIndexRelativeToRenderedTracks();
584
585     // Increment n by one.
586     n++;
587
588     // Negate n.
589     n = -n;
590
591     return n;
592 }
593
594 static bool isCueParagraphSeparator(UChar character)
595 {
596     // Within a cue, paragraph boundaries are only denoted by Type B characters,
597     // such as U+000A LINE FEED (LF), U+0085 NEXT LINE (NEL), and U+2029 PARAGRAPH SEPARATOR.
598     return u_charType(character) == U_PARAGRAPH_SEPARATOR;
599 }
600
601 void VTTCue::determineTextDirection()
602 {
603     static NeverDestroyed<const String> rtTag(ASCIILiteral("rt"));
604     createWebVTTNodeTree();
605     if (!m_webVTTNodeTree)
606         return;
607
608     // Apply the Unicode Bidirectional Algorithm's Paragraph Level steps to the
609     // concatenation of the values of each WebVTT Text Object in nodes, in a
610     // pre-order, depth-first traversal, excluding WebVTT Ruby Text Objects and
611     // their descendants.
612     StringBuilder paragraphBuilder;
613     for (Node* node = m_webVTTNodeTree->firstChild(); node; node = NodeTraversal::next(*node, m_webVTTNodeTree.get())) {
614         // FIXME: The code does not match the comment above. This does not actually exclude Ruby Text Object descendant.
615         if (!node->isTextNode() || node->localName() == rtTag)
616             continue;
617
618         paragraphBuilder.append(node->nodeValue());
619     }
620
621     String paragraph = paragraphBuilder.toString();
622     if (!paragraph.length())
623         return;
624
625     for (size_t i = 0; i < paragraph.length(); ++i) {
626         UChar current = paragraph[i];
627         if (!current || isCueParagraphSeparator(current))
628             return;
629
630         if (UChar current = paragraph[i]) {
631             UCharDirection charDirection = u_charDirection(current);
632             if (charDirection == U_LEFT_TO_RIGHT) {
633                 m_displayDirection = CSSValueLtr;
634                 return;
635             }
636             if (charDirection == U_RIGHT_TO_LEFT || charDirection == U_RIGHT_TO_LEFT_ARABIC) {
637                 m_displayDirection = CSSValueRtl;
638                 return;
639             }
640         }
641     }
642 }
643
644 void VTTCue::calculateDisplayParameters()
645 {
646     // Steps 10.2, 10.3
647     determineTextDirection();
648
649     // 10.4 If the text track cue writing direction is horizontal, then let
650     // block-flow be 'tb'. Otherwise, if the text track cue writing direction is
651     // vertical growing left, then let block-flow be 'lr'. Otherwise, the text
652     // track cue writing direction is vertical growing right; let block-flow be
653     // 'rl'.
654
655     // The above step is done through the writing direction static map.
656
657     // 10.5 Determine the value of maximum size for cue as per the appropriate
658     // rules from the following list:
659     int maximumSize = m_textPosition;
660     if ((m_writingDirection == Horizontal && m_cueAlignment == Start && m_displayDirection == CSSValueLtr)
661         || (m_writingDirection == Horizontal && m_cueAlignment == End && m_displayDirection == CSSValueRtl)
662         || (m_writingDirection == Horizontal && m_cueAlignment == Left)
663         || (m_writingDirection == VerticalGrowingLeft && (m_cueAlignment == Start || m_cueAlignment == Left))
664         || (m_writingDirection == VerticalGrowingRight && (m_cueAlignment == Start || m_cueAlignment == Left))) {
665         maximumSize = 100 - m_textPosition;
666     } else if ((m_writingDirection == Horizontal && m_cueAlignment == End && m_displayDirection == CSSValueLtr)
667         || (m_writingDirection == Horizontal && m_cueAlignment == Start && m_displayDirection == CSSValueRtl)
668         || (m_writingDirection == Horizontal && m_cueAlignment == Right)
669         || (m_writingDirection == VerticalGrowingLeft && (m_cueAlignment == End || m_cueAlignment == Right))
670         || (m_writingDirection == VerticalGrowingRight && (m_cueAlignment == End || m_cueAlignment == Right))) {
671         maximumSize = m_textPosition;
672     } else if (m_cueAlignment == Middle) {
673         maximumSize = m_textPosition <= 50 ? m_textPosition : (100 - m_textPosition);
674         maximumSize = maximumSize * 2;
675     } else
676         ASSERT_NOT_REACHED();
677
678     // 10.6 If the text track cue size is less than maximum size, then let size
679     // be text track cue size. Otherwise, let size be maximum size.
680     m_displaySize = std::min(m_cueSize, maximumSize);
681
682     // FIXME: Understand why step 10.7 is missing (just a copy/paste error?)
683     // Could be done within a spec implementation check - http://crbug.com/301580
684
685     // 10.8 Determine the value of x-position or y-position for cue as per the
686     // appropriate rules from the following list:
687     if (m_writingDirection == Horizontal) {
688         switch (m_cueAlignment) {
689         case Start:
690             if (m_displayDirection == CSSValueLtr)
691                 m_displayPosition.first = m_textPosition;
692             else
693                 m_displayPosition.first = 100 - m_textPosition - m_displaySize;
694             break;
695         case End:
696             if (m_displayDirection == CSSValueRtl)
697                 m_displayPosition.first = 100 - m_textPosition;
698             else
699                 m_displayPosition.first = m_textPosition - m_displaySize;
700             break;
701         case Left:
702             if (m_displayDirection == CSSValueLtr)
703                 m_displayPosition.first = m_textPosition;
704             else
705                 m_displayPosition.first = 100 - m_textPosition;
706             break;
707         case Right:
708             if (m_displayDirection == CSSValueLtr)
709                 m_displayPosition.first = m_textPosition - m_displaySize;
710             else
711                 m_displayPosition.first = 100 - m_textPosition - m_displaySize;
712             break;
713         case Middle:
714             if (m_displayDirection == CSSValueLtr)
715                 m_displayPosition.first = m_textPosition - m_displaySize / 2;
716             else
717                 m_displayPosition.first = 100 - m_textPosition - m_displaySize / 2;
718             break;
719         case NumberOfAlignments:
720             ASSERT_NOT_REACHED();
721         }
722     }
723
724     // A text track cue has a text track cue computed line position whose value
725     // is defined in terms of the other aspects of the cue.
726     m_computedLinePosition = calculateComputedLinePosition();
727
728     // 10.9 Determine the value of whichever of x-position or y-position is not
729     // yet calculated for cue as per the appropriate rules from the following
730     // list:
731     if (m_snapToLines && m_displayPosition.second == undefinedPosition && m_writingDirection == Horizontal)
732         m_displayPosition.second = 0;
733
734     if (!m_snapToLines && m_displayPosition.second == undefinedPosition && m_writingDirection == Horizontal)
735         m_displayPosition.second = m_computedLinePosition;
736
737     if (m_snapToLines && m_displayPosition.first == undefinedPosition
738         && (m_writingDirection == VerticalGrowingLeft || m_writingDirection == VerticalGrowingRight))
739         m_displayPosition.first = 0;
740
741     if (!m_snapToLines && (m_writingDirection == VerticalGrowingLeft || m_writingDirection == VerticalGrowingRight))
742         m_displayPosition.first = m_computedLinePosition;
743 }
744     
745 void VTTCue::markFutureAndPastNodes(ContainerNode* root, const MediaTime& previousTimestamp, const MediaTime& movieTime)
746 {
747     static NeverDestroyed<const String> timestampTag(ASCIILiteral("timestamp"));
748     
749     bool isPastNode = true;
750     MediaTime currentTimestamp = previousTimestamp;
751     if (currentTimestamp > movieTime)
752         isPastNode = false;
753     
754     for (Node* child = root->firstChild(); child; child = NodeTraversal::next(*child, root)) {
755         if (child->nodeName() == timestampTag) {
756             MediaTime currentTimestamp;
757             bool check = WebVTTParser::collectTimeStamp(child->nodeValue(), currentTimestamp);
758             ASSERT_UNUSED(check, check);
759             
760             currentTimestamp += m_originalStartTime;
761             if (currentTimestamp > movieTime)
762                 isPastNode = false;
763         }
764         
765         if (is<WebVTTElement>(*child)) {
766             downcast<WebVTTElement>(*child).setIsPastNode(isPastNode);
767             // Make an elemenet id match a cue id for style matching purposes.
768             if (!id().isEmpty())
769                 downcast<WebVTTElement>(*child).setIdAttribute(id());
770         }
771     }
772 }
773
774 void VTTCue::updateDisplayTree(const MediaTime& movieTime)
775 {
776     // The display tree may contain WebVTT timestamp objects representing
777     // timestamps (processing instructions), along with displayable nodes.
778
779     if (!track()->isRendered())
780         return;
781
782     // Clear the contents of the set.
783     m_cueHighlightBox->removeChildren();
784
785     // Update the two sets containing past and future WebVTT objects.
786     RefPtr<DocumentFragment> referenceTree = createCueRenderingTree();
787     if (!referenceTree)
788         return;
789
790     markFutureAndPastNodes(referenceTree.get(), startMediaTime(), movieTime);
791     m_cueHighlightBox->appendChild(*referenceTree);
792 }
793
794 VTTCueBox& VTTCue::getDisplayTree(const IntSize& videoSize, int fontSize)
795 {
796     Ref<VTTCueBox> displayTree = displayTreeInternal();
797     if (!m_displayTreeShouldChange || !track()->isRendered())
798         return displayTree.get();
799
800     // 10.1 - 10.10
801     calculateDisplayParameters();
802
803     // 10.11. Apply the terms of the CSS specifications to nodes within the
804     // following constraints, thus obtaining a set of CSS boxes positioned
805     // relative to an initial containing block:
806     displayTree->removeChildren();
807
808     // The document tree is the tree of WebVTT Node Objects rooted at nodes.
809
810     // The children of the nodes must be wrapped in an anonymous box whose
811     // 'display' property has the value 'inline'. This is the WebVTT cue
812     // background box.
813
814     // Note: This is contained by default in m_cueHighlightBox.
815     m_cueHighlightBox->setPseudo(cueShadowPseudoId());
816
817     m_cueBackdropBox->setPseudo(cueBackdropShadowPseudoId());
818     m_cueBackdropBox->appendChild(*m_cueHighlightBox);
819     displayTree->appendChild(*m_cueBackdropBox);
820
821     // FIXME(BUG 79916): Runs of children of WebVTT Ruby Objects that are not
822     // WebVTT Ruby Text Objects must be wrapped in anonymous boxes whose
823     // 'display' property has the value 'ruby-base'.
824
825     displayTree->setFontSizeFromCaptionUserPrefs(fontSize);
826     displayTree->applyCSSProperties(videoSize);
827
828     m_displayTreeShouldChange = false;
829
830     // 10.15. Let cue's text track cue display state have the CSS boxes in
831     // boxes.
832     return displayTree.get();
833 }
834
835 void VTTCue::removeDisplayTree()
836 {
837     // The region needs to be informed about the cue removal.
838     if (m_notifyRegion && track()) {
839         if (VTTRegionList* regions = track()->regions()) {
840             if (VTTRegion* region = regions->getRegionById(m_regionId))
841                 if (hasDisplayTree())
842                     region->willRemoveTextTrackCueBox(m_displayTree.get());
843         }
844     }
845
846     if (!hasDisplayTree())
847         return;
848     displayTreeInternal().remove();
849 }
850
851 std::pair<double, double> VTTCue::getPositionCoordinates() const
852 {
853     // This method is used for setting x and y when snap to lines is not set.
854     std::pair<double, double> coordinates;
855
856     if (m_writingDirection == Horizontal && m_displayDirection == CSSValueLtr) {
857         coordinates.first = m_textPosition;
858         coordinates.second = m_computedLinePosition;
859
860         return coordinates;
861     }
862
863     if (m_writingDirection == Horizontal && m_displayDirection == CSSValueRtl) {
864         coordinates.first = 100 - m_textPosition;
865         coordinates.second = m_computedLinePosition;
866
867         return coordinates;
868     }
869
870     if (m_writingDirection == VerticalGrowingLeft) {
871         coordinates.first = 100 - m_computedLinePosition;
872         coordinates.second = m_textPosition;
873
874         return coordinates;
875     }
876
877     if (m_writingDirection == VerticalGrowingRight) {
878         coordinates.first = m_computedLinePosition;
879         coordinates.second = m_textPosition;
880
881         return coordinates;
882     }
883
884     ASSERT_NOT_REACHED();
885
886     return coordinates;
887 }
888
889 VTTCue::CueSetting VTTCue::settingName(VTTScanner& input)
890 {
891     CueSetting parsedSetting = None;
892     if (input.scan("vertical"))
893         parsedSetting = Vertical;
894     else if (input.scan("line"))
895         parsedSetting = Line;
896     else if (input.scan("position"))
897         parsedSetting = Position;
898     else if (input.scan("size"))
899         parsedSetting = Size;
900     else if (input.scan("align"))
901         parsedSetting = Align;
902     else if (input.scan("region"))
903         parsedSetting = RegionId;
904
905     // Verify that a ':' follows.
906     if (parsedSetting != None && input.scan(':'))
907         return parsedSetting;
908
909     return None;
910 }
911
912 void VTTCue::setCueSettings(const String& inputString)
913 {
914     if (inputString.isEmpty())
915         return;
916
917     VTTScanner input(inputString);
918
919     while (!input.isAtEnd()) {
920
921         // The WebVTT cue settings part of a WebVTT cue consists of zero or more of the following components, in any order, 
922         // separated from each other by one or more U+0020 SPACE characters or U+0009 CHARACTER TABULATION (tab) characters.
923         input.skipWhile<WebVTTParser::isValidSettingDelimiter>();
924         if (input.isAtEnd())
925             break;
926
927         // When the user agent is to parse the WebVTT settings given by a string input for a text track cue cue, 
928         // the user agent must run the following steps:
929         // 1. Let settings be the result of splitting input on spaces.
930         // 2. For each token setting in the list settings, run the following substeps:
931         //    1. If setting does not contain a U+003A COLON character (:), or if the first U+003A COLON character (:) 
932         //       in setting is either the first or last character of setting, then jump to the step labeled next setting.
933         //    2. Let name be the leading substring of setting up to and excluding the first U+003A COLON character (:) in that string.
934         CueSetting name = settingName(input);
935
936         // 3. Let value be the trailing substring of setting starting from the character immediately after the first U+003A COLON character (:) in that string.
937         VTTScanner::Run valueRun = input.collectUntil<WebVTTParser::isValidSettingDelimiter>();
938
939         // 4. Run the appropriate substeps that apply for the value of name, as follows:
940         switch (name) {
941         case Vertical: {
942             // If name is a case-sensitive match for "vertical"
943             // 1. If value is a case-sensitive match for the string "rl", then let cue's text track cue writing direction 
944             //    be vertical growing left.
945             if (input.scanRun(valueRun, verticalGrowingLeftKeyword()))
946                 m_writingDirection = VerticalGrowingLeft;
947             
948             // 2. Otherwise, if value is a case-sensitive match for the string "lr", then let cue's text track cue writing 
949             //    direction be vertical growing right.
950             else if (input.scanRun(valueRun, verticalGrowingRightKeyword()))
951                 m_writingDirection = VerticalGrowingRight;
952
953             else
954                 LOG(Media, "VTTCue::setCueSettings, invalid Vertical");
955             break;
956         }
957         case Line: {
958             bool isValid = false;
959             do {
960                 // 1-2 - Collect chars that are either '-', '%', or a digit.
961                 // 1. If value contains any characters other than U+002D HYPHEN-MINUS characters (-), U+0025 PERCENT SIGN
962                 //    characters (%), and characters in the range U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9), then jump
963                 //    to the step labeled next setting.
964                 float linePosition;
965                 bool isNegative;
966                 if (!input.scanFloat(linePosition, &isNegative))
967                     break;
968
969                 bool isPercentage = input.scan('%');
970                 if (!input.isAt(valueRun.end()))
971                     break;
972
973                 // 2. If value does not contain at least one character in the range U+0030 DIGIT ZERO (0) to U+0039 DIGIT
974                 //    NINE (9), then jump to the step labeled next setting.
975                 // 3. If any character in value other than the first character is a U+002D HYPHEN-MINUS character (-), then
976                 //    jump to the step labeled next setting.
977                 // 4. If any character in value other than the last character is a U+0025 PERCENT SIGN character (%), then
978                 //    jump to the step labeled next setting.
979                 // 5. If the first character in value is a U+002D HYPHEN-MINUS character (-) and the last character in value is a
980                 //    U+0025 PERCENT SIGN character (%), then jump to the step labeled next setting.
981                 if (isPercentage && isNegative)
982                     break;
983
984                 // 6. Ignoring the trailing percent sign, if any, interpret value as a (potentially signed) integer, and
985                 //    let number be that number.
986                 // 7. If the last character in value is a U+0025 PERCENT SIGN character (%), but number is not in the range
987                 //    0 ≤ number ≤ 100, then jump to the step labeled next setting.
988                 // 8. Let cue's text track cue line position be number.
989                 // 9. If the last character in value is a U+0025 PERCENT SIGN character (%), then let cue's text track cue
990                 //    snap-to-lines flag be false. Otherwise, let it be true.
991                 if (isPercentage) {
992                     if (linePosition < 0 || linePosition > 100)
993                         break;
994
995                     // 10 - If '%' then set snap-to-lines flag to false.
996                     m_snapToLines = false;
997                 } else {
998                     if (linePosition - static_cast<int>(linePosition))
999                         break;
1000
1001                     m_snapToLines = true;
1002                 }
1003                 
1004                 m_linePosition = linePosition;
1005                 isValid = true;
1006             } while (0);
1007
1008             if (!isValid)
1009                 LOG(Media, "VTTCue::setCueSettings, invalid Line");
1010
1011             break;
1012         }
1013         case Position: {
1014             float position;
1015             if (WebVTTParser::parseFloatPercentageValue(input, position) && input.isAt(valueRun.end()))
1016                 m_textPosition = position;
1017             else
1018                 LOG(Media, "VTTCue::setCueSettings, invalid Position");
1019             break;
1020         }
1021         case Size: {
1022             float cueSize;
1023             if (WebVTTParser::parseFloatPercentageValue(input, cueSize) && input.isAt(valueRun.end()))
1024                 m_cueSize = cueSize;
1025             else
1026                 LOG(Media, "VTTCue::setCueSettings, invalid Size");
1027             break;
1028         }
1029         case Align: {
1030             // 1. If value is a case-sensitive match for the string "start", then let cue's text track cue alignment be start alignment.
1031             if (input.scanRun(valueRun, startKeyword()))
1032                 m_cueAlignment = Start;
1033
1034             // 2. If value is a case-sensitive match for the string "middle", then let cue's text track cue alignment be middle alignment.
1035             else if (input.scanRun(valueRun, middleKeyword()))
1036                 m_cueAlignment = Middle;
1037
1038             // 3. If value is a case-sensitive match for the string "end", then let cue's text track cue alignment be end alignment.
1039             else if (input.scanRun(valueRun, endKeyword()))
1040                 m_cueAlignment = End;
1041
1042             // 4. If value is a case-sensitive match for the string "left", then let cue's text track cue alignment be left alignment.
1043             else if (input.scanRun(valueRun, leftKeyword()))
1044                 m_cueAlignment = Left;
1045
1046             // 5. If value is a case-sensitive match for the string "right", then let cue's text track cue alignment be right alignment.
1047             else if (input.scanRun(valueRun, rightKeyword()))
1048                 m_cueAlignment = Right;
1049
1050             else
1051                 LOG(Media, "VTTCue::setCueSettings, invalid Align");
1052
1053             break;
1054         }
1055         case RegionId:
1056             m_regionId = input.extractString(valueRun);
1057             break;
1058         case None:
1059             break;
1060         }
1061
1062         // Make sure the entire run is consumed.
1063         input.skipRun(valueRun);
1064     }
1065
1066     // If cue's line position is not auto or cue's size is not 100 or cue's
1067     // writing direction is not horizontal, but cue's region identifier is not
1068     // the empty string, let cue's region identifier be the empty string.
1069     if (m_regionId.isEmpty())
1070         return;
1071
1072     if (m_linePosition != undefinedPosition || m_cueSize != 100 || m_writingDirection != Horizontal)
1073         m_regionId = emptyString();
1074 }
1075
1076 CSSValueID VTTCue::getCSSAlignment() const
1077 {
1078     return displayAlignmentMap[m_cueAlignment];
1079 }
1080
1081 CSSValueID VTTCue::getCSSWritingDirection() const
1082 {
1083     return m_displayDirection;
1084 }
1085
1086 CSSValueID VTTCue::getCSSWritingMode() const
1087 {
1088     return displayWritingModeMap[m_writingDirection];
1089 }
1090
1091 int VTTCue::getCSSSize() const
1092 {
1093     return m_displaySize;
1094 }
1095
1096 std::pair<double, double> VTTCue::getCSSPosition() const
1097 {
1098     if (!m_snapToLines)
1099         return getPositionCoordinates();
1100
1101     return m_displayPosition;
1102 }
1103
1104 bool VTTCue::cueContentsMatch(const TextTrackCue& cue) const
1105 {
1106     const VTTCue* vttCue = toVTTCue(&cue);
1107     if (text() != vttCue->text())
1108         return false;
1109     if (cueSettings() != vttCue->cueSettings())
1110         return false;
1111     if (position() != vttCue->position())
1112         return false;
1113     if (line() != vttCue->line())
1114         return false;
1115     if (size() != vttCue->size())
1116         return false;
1117     if (align() != vttCue->align())
1118         return false;
1119     
1120     return true;
1121 }
1122
1123 bool VTTCue::isEqual(const TextTrackCue& cue, TextTrackCue::CueMatchRules match) const
1124 {
1125     if (!TextTrackCue::isEqual(cue, match))
1126         return false;
1127
1128     if (cue.cueType() != WebVTT)
1129         return false;
1130
1131     return cueContentsMatch(cue);
1132 }
1133
1134 bool VTTCue::doesExtendCue(const TextTrackCue& cue) const
1135 {
1136     if (!cueContentsMatch(cue))
1137         return false;
1138     
1139     return TextTrackCue::doesExtendCue(cue);
1140 }
1141     
1142 void VTTCue::setFontSize(int fontSize, const IntSize&, bool important)
1143 {
1144     if (!hasDisplayTree() || !fontSize)
1145         return;
1146     
1147     LOG(Media, "TextTrackCue::setFontSize - setting cue font size to %i", fontSize);
1148
1149     m_displayTreeShouldChange = true;
1150     displayTreeInternal().setInlineStyleProperty(CSSPropertyFontSize, fontSize, CSSPrimitiveValue::CSS_PX, important);
1151 }
1152
1153 VTTCue* toVTTCue(TextTrackCue* cue)
1154 {
1155     return const_cast<VTTCue*>(toVTTCue(const_cast<const TextTrackCue*>(cue)));
1156 }
1157
1158 const VTTCue* toVTTCue(const TextTrackCue* cue)
1159 {
1160     ASSERT_WITH_SECURITY_IMPLICATION(cue->isRenderable());
1161     return static_cast<const VTTCue*>(cue);
1162 }
1163
1164 } // namespace WebCore
1165
1166 #endif