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