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