The 'global isinf/isnan' compiler quirk required when using clang with libstdc++
[WebKit.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 "HTMLMediaElement.h"
44 #include "HTMLSpanElement.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     // FIXME: Determine the text direction using the BIDI algorithm. http://wkb.ug/79749
123     // the 'direction' property must be set to direction
124     setInlineStyleProperty(CSSPropertyDirection, CSSValueLtr);
125
126     // the 'writing-mode' property must be set to writing-mode
127     setInlineStyleProperty(CSSPropertyWebkitWritingMode, m_cue->getCSSWritingMode(), false);
128
129     std::pair<float, float> position = m_cue->getCSSPosition();
130
131     // the 'top' property must be set to top,
132     setInlineStyleProperty(CSSPropertyTop, static_cast<double>(position.second), CSSPrimitiveValue::CSS_PERCENTAGE);
133
134     // the 'left' property must be set to left
135     setInlineStyleProperty(CSSPropertyLeft, static_cast<double>(position.first), CSSPrimitiveValue::CSS_PERCENTAGE);
136
137     // the 'width' property must be set to width, and the 'height' property  must be set to height
138     if (m_cue->vertical() == horizontalKeyword()) {
139         setInlineStyleProperty(CSSPropertyWidth, static_cast<double>(m_cue->getCSSSize()), CSSPrimitiveValue::CSS_PERCENTAGE);
140         setInlineStyleProperty(CSSPropertyHeight, CSSValueAuto);
141     } else {
142         setInlineStyleProperty(CSSPropertyWidth, CSSValueAuto);
143         setInlineStyleProperty(CSSPropertyHeight, static_cast<double>(m_cue->getCSSSize()),  CSSPrimitiveValue::CSS_PERCENTAGE);
144     }
145
146     // The 'text-align' property on the (root) List of WebVTT Node Objects must
147     // be set to the value in the second cell of the row of the table below
148     // whose first cell is the value of the corresponding cue's text track cue
149     // alignment:
150     if (m_cue->align() == startKeyword())
151         setInlineStyleProperty(CSSPropertyTextAlign, CSSValueStart);
152     else if (m_cue->align() == endKeyword())
153         setInlineStyleProperty(CSSPropertyTextAlign, CSSValueEnd);
154     else
155         setInlineStyleProperty(CSSPropertyTextAlign, CSSValueCenter);
156
157     if (!m_cue->snapToLines()) {
158         // 10.13.1 Set up x and y:
159         // Note: x and y are set through the CSS left and top above.
160
161         // 10.13.2 Position the boxes in boxes such that the point x% along the
162         // width of the bounding box of the boxes in boxes is x% of the way
163         // across the width of the video's rendering area, and the point y%
164         // along the height of the bounding box of the boxes in boxes is y%
165         // of the way across the height of the video's rendering area, while
166         // maintaining the relative positions of the boxes in boxes to each
167         // other.
168         setInlineStyleProperty(CSSPropertyWebkitTransform,
169                 String::format("translate(-%.2f%%, -%.2f%%)", position.first, position.second));
170
171         setInlineStyleProperty(CSSPropertyWhiteSpace, CSSValuePre);
172     }
173 }
174
175 const AtomicString& TextTrackCueBox::textTrackCueBoxShadowPseudoId()
176 {
177     DEFINE_STATIC_LOCAL(const AtomicString, trackDisplayBoxShadowPseudoId, ("-webkit-media-text-track-display", AtomicString::ConstructFromLiteral));
178     return trackDisplayBoxShadowPseudoId;
179 }
180
181 RenderObject* TextTrackCueBox::createRenderer(RenderArena* arena, RenderStyle*)
182 {
183     return new (arena) RenderTextTrackCue(this);
184 }
185
186 // ----------------------------
187
188 const AtomicString& TextTrackCue::allNodesShadowPseudoId()
189 {
190     DEFINE_STATIC_LOCAL(const AtomicString, subtitles, ("-webkit-media-text-track-all-nodes", AtomicString::ConstructFromLiteral));
191     return subtitles;
192 }
193
194 TextTrackCue::TextTrackCue(ScriptExecutionContext* context, double start, double end, const String& content)
195     : m_startTime(start)
196     , m_endTime(end)
197     , m_content(content)
198     , m_linePosition(undefinedPosition)
199     , m_computedLinePosition(undefinedPosition)
200     , m_textPosition(50)
201     , m_cueSize(100)
202     , m_cueIndex(invalidCueIndex)
203     , m_writingDirection(Horizontal)
204     , m_cueAlignment(Middle)
205     , m_webVTTNodeTree(0)
206     , m_track(0)
207     , m_scriptExecutionContext(context)
208     , m_isActive(false)
209     , m_pauseOnExit(false)
210     , m_snapToLines(true)
211     , m_allDocumentNodes(HTMLDivElement::create(static_cast<Document*>(context)))
212     , m_displayTreeShouldChange(true)
213 {
214     ASSERT(m_scriptExecutionContext->isDocument());
215
216     // 4. If the text track cue writing direction is horizontal, then let
217     // writing-mode be 'horizontal-tb'. Otherwise, if the text track cue writing
218     // direction is vertical growing left, then let writing-mode be
219     // 'vertical-rl'. Otherwise, the text track cue writing direction is
220     // vertical growing right; let writing-mode be 'vertical-lr'.
221     m_displayWritingModeMap[Horizontal] = CSSValueHorizontalTb;
222     m_displayWritingModeMap[VerticalGrowingLeft] = CSSValueVerticalRl;
223     m_displayWritingModeMap[VerticalGrowingRight] = CSSValueVerticalLr;
224 }
225
226 TextTrackCue::~TextTrackCue()
227 {
228     removeDisplayTree();
229 }
230
231 PassRefPtr<TextTrackCueBox> TextTrackCue::createDisplayTree()
232 {
233     return TextTrackCueBox::create(ownerDocument(), this);
234 }
235
236 PassRefPtr<TextTrackCueBox> TextTrackCue::displayTreeInternal()
237 {
238     if (!m_displayTree)
239         m_displayTree = createDisplayTree();
240     return m_displayTree;
241 }
242
243 void TextTrackCue::cueWillChange()
244 {
245     if (m_track)
246         m_track->cueWillChange(this);
247 }
248
249 void TextTrackCue::cueDidChange()
250 {
251     if (m_track)
252         m_track->cueDidChange(this);
253
254     m_displayTreeShouldChange = true;
255 }
256
257 TextTrack* TextTrackCue::track() const
258 {
259     return m_track;
260 }
261
262 void TextTrackCue::setTrack(TextTrack* track)
263 {
264     m_track = track;
265 }
266
267 void TextTrackCue::setId(const String& id)
268 {
269     if (m_id == id)
270         return;
271
272     cueWillChange();
273     m_id = id;
274     cueDidChange();
275 }
276
277 void TextTrackCue::setStartTime(double value, ExceptionCode& ec)
278 {
279     // NaN, Infinity and -Infinity values should trigger a TypeError.
280     if (std::isinf(value) || std::isnan(value)) {
281         ec = TypeError;
282         return;
283     }
284     
285     // TODO(93143): Add spec-compliant behavior for negative time values.
286     if (m_startTime == value || value < 0)
287         return;
288     
289     cueWillChange();
290     m_startTime = value;
291     cueDidChange();
292 }
293     
294 void TextTrackCue::setEndTime(double value, ExceptionCode& ec)
295 {
296     // NaN, Infinity and -Infinity values should trigger a TypeError.
297     if (std::isinf(value) || std::isnan(value)) {
298         ec = TypeError;
299         return;
300     }
301
302     // TODO(93143): Add spec-compliant behavior for negative time values.
303     if (m_endTime == value || value < 0)
304         return;
305     
306     cueWillChange();
307     m_endTime = value;
308     cueDidChange();
309 }
310     
311 void TextTrackCue::setPauseOnExit(bool value)
312 {
313     if (m_pauseOnExit == value)
314         return;
315     
316     cueWillChange();
317     m_pauseOnExit = value;
318     cueDidChange();
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     cueWillChange();
358     m_writingDirection = direction;
359     cueDidChange();
360 }
361
362 void TextTrackCue::setSnapToLines(bool value)
363 {
364     if (m_snapToLines == value)
365         return;
366     
367     cueWillChange();
368     m_snapToLines = value;
369     cueDidChange();
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     cueWillChange();
387     m_linePosition = position;
388     m_computedLinePosition = calculateComputedLinePosition();
389     cueDidChange();
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     cueWillChange();
407     m_textPosition = position;
408     cueDidChange();
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     cueWillChange();
426     m_cueSize = size;
427     cueDidChange();
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     cueWillChange();
467     m_cueAlignment = alignment;
468     cueDidChange();
469 }
470     
471 void TextTrackCue::setText(const String& text)
472 {
473     if (m_content == text)
474         return;
475     
476     cueWillChange();
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     cueDidChange();
482 }
483
484 int TextTrackCue::cueIndex()
485 {
486     if (m_cueIndex == invalidCueIndex)
487         m_cueIndex = track()->cues()->getCueIndex(this);
488
489     return m_cueIndex;
490 }
491
492 void TextTrackCue::invalidateCueIndex()
493 {
494     m_cueIndex = invalidCueIndex;
495 }
496
497 void TextTrackCue::createWebVTTNodeTree()
498 {
499     if (!m_webVTTNodeTree)
500         m_webVTTNodeTree = WebVTTParser::create(0, m_scriptExecutionContext)->createDocumentFragmentFromCueText(m_content);
501 }
502
503 void TextTrackCue::copyWebVTTNodeToDOMTree(ContainerNode* webVTTNode, ContainerNode* parent)
504 {
505     for (Node* node = webVTTNode->firstChild(); node; node = node->nextSibling()) {
506         RefPtr<Node> clonedNode;
507         if (node->isWebVTTElement())
508             clonedNode = toWebVTTElement(node)->createEquivalentHTMLElement(ownerDocument());
509         else
510             clonedNode = node->cloneNode(false);
511         parent->appendChild(clonedNode, ASSERT_NO_EXCEPTION);
512         if (node->isContainerNode())
513             copyWebVTTNodeToDOMTree(toContainerNode(node), toContainerNode(clonedNode.get()));
514     }
515 }
516
517 PassRefPtr<DocumentFragment> TextTrackCue::getCueAsHTML()
518 {
519     createWebVTTNodeTree();
520     RefPtr<DocumentFragment> clonedFragment = DocumentFragment::create(ownerDocument());
521     copyWebVTTNodeToDOMTree(m_webVTTNodeTree.get(), clonedFragment.get());
522     return clonedFragment.release();
523 }
524
525 PassRefPtr<DocumentFragment> TextTrackCue::createCueRenderingTree()
526 {
527     RefPtr<DocumentFragment> clonedFragment;
528     createWebVTTNodeTree();
529     clonedFragment = DocumentFragment::create(ownerDocument());
530     m_webVTTNodeTree->cloneChildNodes(clonedFragment.get());
531     return clonedFragment.release();
532 }
533
534 bool TextTrackCue::dispatchEvent(PassRefPtr<Event> event)
535 {
536     // When a TextTrack's mode is disabled: no cues are active, no events fired.
537     if (!track() || track()->mode() == TextTrack::disabledKeyword())
538         return false;
539
540     return EventTarget::dispatchEvent(event);
541 }
542
543 bool TextTrackCue::isActive()
544 {
545     return m_isActive && track() && track()->mode() != TextTrack::disabledKeyword();
546 }
547
548 void TextTrackCue::setIsActive(bool active)
549 {
550     m_isActive = active;
551
552     if (!active) {
553         // Remove the display tree as soon as the cue becomes inactive.
554         displayTreeInternal()->remove(ASSERT_NO_EXCEPTION);
555     }
556 }
557
558 int TextTrackCue::calculateComputedLinePosition()
559 {
560     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#text-track-cue-computed-line-position
561
562     // If the text track cue line position is numeric, then that is the text
563     // track cue computed line position.
564     if (m_linePosition != undefinedPosition)
565         return m_linePosition;
566
567     // If the text track cue snap-to-lines flag of the text track cue is not
568     // set, the text track cue computed line position is the value 100;
569     if (!m_snapToLines)
570         return 100;
571
572     // Otherwise, it is the value returned by the following algorithm:
573
574     // If cue is not associated with a text track, return -1 and abort these
575     // steps.
576     if (!track())
577         return -1;
578
579     // Let n be the number of text tracks whose text track mode is showing or
580     // showing by default and that are in the media element's list of text
581     // tracks before track.
582     int n = track()->trackIndexRelativeToRenderedTracks();
583
584     // Increment n by one.
585     n++;
586
587     // Negate n.
588     n = -n;
589
590     return n;
591 }
592
593 void TextTrackCue::calculateDisplayParameters()
594 {
595     // FIXME(BUG 79749): Determine the text direction using the BIDI algorithm.
596     // Steps 10.2, 10.3
597     m_displayDirection = CSSValueLtr;
598
599     // 10.4 If the text track cue writing direction is horizontal, then let
600     // block-flow be 'tb'. Otherwise, if the text track cue writing direction is
601     // vertical growing left, then let block-flow be 'lr'. Otherwise, the text
602     // track cue writing direction is vertical growing right; let block-flow be
603     // 'rl'.
604     m_displayWritingMode = m_displayWritingModeMap[m_writingDirection];
605
606     // 10.5 Determine the value of maximum size for cue as per the appropriate
607     // rules from the following list:
608     int maximumSize = m_textPosition;
609     if ((m_writingDirection == Horizontal && m_cueAlignment == Start && m_displayDirection == CSSValueLtr)
610             || (m_writingDirection == Horizontal && m_cueAlignment == End && m_displayDirection == CSSValueRtl)
611             || (m_writingDirection == VerticalGrowingLeft && m_cueAlignment == Start)
612             || (m_writingDirection == VerticalGrowingRight && m_cueAlignment == Start)) {
613         maximumSize = 100 - m_textPosition;
614     } else if ((m_writingDirection == Horizontal && m_cueAlignment == End && m_displayDirection == CSSValueLtr)
615             || (m_writingDirection == Horizontal && m_cueAlignment == Start && m_displayDirection == CSSValueRtl)
616             || (m_writingDirection == VerticalGrowingLeft && m_cueAlignment == End)
617             || (m_writingDirection == VerticalGrowingRight && m_cueAlignment == End)) {
618         maximumSize = m_textPosition;
619     } else if (m_cueAlignment == Middle) {
620         maximumSize = m_textPosition <= 50 ? m_textPosition : (100 - m_textPosition);
621         maximumSize = maximumSize * 2;
622     }
623
624     // 10.6 If the text track cue size is less than maximum size, then let size
625     // be text track cue size. Otherwise, let size be maximum size.
626     m_displaySize = std::min(m_cueSize, maximumSize);
627
628     // 10.8 Determine the value of x-position or y-position for cue as per the
629     // appropriate rules from the following list:
630     if (m_writingDirection == Horizontal) {
631         if (m_cueAlignment == Start) {
632             if (m_displayDirection == CSSValueLtr)
633                 m_displayPosition.first = m_textPosition;
634             else
635                 m_displayPosition.first = 100 - m_textPosition - m_displaySize;
636         } else if (m_cueAlignment == End) {
637             if (m_displayDirection == CSSValueRtl)
638                 m_displayPosition.first = 100 - m_textPosition;
639             else
640                 m_displayPosition.first = m_textPosition - m_displaySize;
641         }
642     }
643
644     if ((m_writingDirection == VerticalGrowingLeft && m_cueAlignment == Start)
645             || (m_writingDirection == VerticalGrowingRight && m_cueAlignment == Start)) {
646         m_displayPosition.second = m_textPosition;
647     } else if ((m_writingDirection == VerticalGrowingLeft && m_cueAlignment == End)
648             || (m_writingDirection == VerticalGrowingRight && m_cueAlignment == End)) {
649         m_displayPosition.second = 100 - m_textPosition;
650     }
651
652     if (m_writingDirection == Horizontal && m_cueAlignment == Middle) {
653         if (m_displayDirection == CSSValueLtr)
654             m_displayPosition.first = m_textPosition - m_displaySize / 2;
655         else
656            m_displayPosition.first = 100 - m_textPosition - m_displaySize / 2;
657     }
658
659     if ((m_writingDirection == VerticalGrowingLeft && m_cueAlignment == Middle)
660         || (m_writingDirection == VerticalGrowingRight && m_cueAlignment == Middle))
661         m_displayPosition.second = m_textPosition - m_displaySize / 2;
662
663     // 10.9 Determine the value of whichever of x-position or y-position is not
664     // yet calculated for cue as per the appropriate rules from the following
665     // list:
666     if (m_snapToLines && m_displayPosition.second == undefinedPosition && m_writingDirection == Horizontal)
667         m_displayPosition.second = 0;
668
669     if (!m_snapToLines && m_displayPosition.second == undefinedPosition && m_writingDirection == Horizontal)
670         m_displayPosition.second = m_computedLinePosition;
671
672     if (m_snapToLines && m_displayPosition.first == undefinedPosition
673             && (m_writingDirection == VerticalGrowingLeft || m_writingDirection == VerticalGrowingRight))
674         m_displayPosition.first = 0;
675
676     if (!m_snapToLines && (m_writingDirection == VerticalGrowingLeft || m_writingDirection == VerticalGrowingRight))
677         m_displayPosition.first = m_computedLinePosition;
678
679     // A text track cue has a text track cue computed line position whose value
680     // is defined in terms of the other aspects of the cue.
681     m_computedLinePosition = calculateComputedLinePosition();
682 }
683     
684 void TextTrackCue::markFutureAndPastNodes(ContainerNode* root, double previousTimestamp, double movieTime)
685 {
686     DEFINE_STATIC_LOCAL(const String, timestampTag, (ASCIILiteral("timestamp")));
687     
688     bool isPastNode = true;
689     double currentTimestamp = previousTimestamp;
690     if (currentTimestamp > movieTime)
691         isPastNode = false;
692     
693     for (Node* child = root->firstChild(); child; child = NodeTraversal::next(child, root)) {
694         if (child->nodeName() == timestampTag) {
695             unsigned position = 0;
696             String timestamp = child->nodeValue();
697             double currentTimestamp = WebVTTParser::create(0, m_scriptExecutionContext)->collectTimeStamp(timestamp, &position);
698             ASSERT(currentTimestamp != -1);
699             
700             if (currentTimestamp > movieTime)
701                 isPastNode = false;
702         }
703         
704         if (child->isWebVTTElement()) {
705             toWebVTTElement(child)->setIsPastNode(isPastNode);
706             // Make an elemenet id match a cue id for style matching purposes.
707             if (!m_id.isEmpty())
708                 toElement(child)->setIdAttribute(AtomicString(m_id.characters(), m_id.length()));
709         }
710     }
711 }
712
713 void TextTrackCue::updateDisplayTree(float movieTime)
714 {
715     // The display tree may contain WebVTT timestamp objects representing
716     // timestamps (processing instructions), along with displayable nodes.
717
718     if (!track()->isRendered())
719       return;
720
721     // Clear the contents of the set.
722     m_allDocumentNodes->removeChildren();
723
724     // Update the two sets containing past and future WebVTT objects.
725     RefPtr<DocumentFragment> referenceTree = createCueRenderingTree();
726     markFutureAndPastNodes(referenceTree.get(), startTime(), movieTime);
727     m_allDocumentNodes->appendChild(referenceTree);
728 }
729
730 PassRefPtr<TextTrackCueBox> TextTrackCue::getDisplayTree(const IntSize& videoSize)
731 {
732     RefPtr<TextTrackCueBox> displayTree = displayTreeInternal();
733     if (!m_displayTreeShouldChange || !track()->isRendered())
734         return displayTree;
735
736     // 10.1 - 10.10
737     calculateDisplayParameters();
738
739     // 10.11. Apply the terms of the CSS specifications to nodes within the
740     // following constraints, thus obtaining a set of CSS boxes positioned
741     // relative to an initial containing block:
742     displayTree->removeChildren();
743
744     // The document tree is the tree of WebVTT Node Objects rooted at nodes.
745
746     // The children of the nodes must be wrapped in an anonymous box whose
747     // 'display' property has the value 'inline'. This is the WebVTT cue
748     // background box.
749
750     // Note: This is contained by default in m_allDocumentNodes.
751     m_allDocumentNodes->setPseudo(allNodesShadowPseudoId());
752     displayTree->appendChild(m_allDocumentNodes, ASSERT_NO_EXCEPTION, true);
753
754     // FIXME(BUG 79916): Runs of children of WebVTT Ruby Objects that are not
755     // WebVTT Ruby Text Objects must be wrapped in anonymous boxes whose
756     // 'display' property has the value 'ruby-base'.
757
758     // FIXME(BUG 79916): Text runs must be wrapped according to the CSS
759     // line-wrapping rules, except that additionally, regardless of the value of
760     // the 'white-space' property, lines must be wrapped at the edge of their
761     // containing blocks, even if doing so requires splitting a word where there
762     // is no line breaking opportunity. (Thus, normally text wraps as needed,
763     // but if there is a particularly long word, it does not overflow as it
764     // normally would in CSS, it is instead forcibly wrapped at the box's edge.)
765     displayTree->applyCSSProperties(videoSize);
766
767     m_displayTreeShouldChange = false;
768
769     // 10.15. Let cue's text track cue display state have the CSS boxes in
770     // boxes.
771     return displayTree;
772 }
773
774 void TextTrackCue::removeDisplayTree()
775 {
776     displayTreeInternal()->remove(ASSERT_NO_EXCEPTION);
777 }
778
779 std::pair<double, double> TextTrackCue::getPositionCoordinates() const
780 {
781     // This method is used for setting x and y when snap to lines is not set.
782     std::pair<double, double> coordinates;
783
784     if (m_writingDirection == Horizontal && m_displayDirection == CSSValueLtr) {
785         coordinates.first = m_textPosition;
786         coordinates.second = m_computedLinePosition;
787
788         return coordinates;
789     }
790
791     if (m_writingDirection == Horizontal && m_displayDirection == CSSValueRtl) {
792         coordinates.first = 100 - m_textPosition;
793         coordinates.second = m_computedLinePosition;
794
795         return coordinates;
796     }
797
798     if (m_writingDirection == VerticalGrowingLeft) {
799         coordinates.first = 100 - m_computedLinePosition;
800         coordinates.second = m_textPosition;
801
802         return coordinates;
803     }
804
805     if (m_writingDirection == VerticalGrowingRight) {
806         coordinates.first = m_computedLinePosition;
807         coordinates.second = m_textPosition;
808
809         return coordinates;
810     }
811
812     ASSERT_NOT_REACHED();
813
814     return coordinates;
815 }
816
817 TextTrackCue::CueSetting TextTrackCue::settingName(const String& name)
818 {
819     DEFINE_STATIC_LOCAL(const String, verticalKeyword, (ASCIILiteral("vertical")));
820     DEFINE_STATIC_LOCAL(const String, lineKeyword, (ASCIILiteral("line")));
821     DEFINE_STATIC_LOCAL(const String, positionKeyword, (ASCIILiteral("position")));
822     DEFINE_STATIC_LOCAL(const String, sizeKeyword, (ASCIILiteral("size")));
823     DEFINE_STATIC_LOCAL(const String, alignKeyword, (ASCIILiteral("align")));
824
825     if (name == verticalKeyword)
826         return Vertical;
827     else if (name == lineKeyword)
828         return Line;
829     else if (name == positionKeyword)
830         return Position;
831     else if (name == sizeKeyword)
832         return Size;
833     else if (name == alignKeyword)
834         return Align;
835
836     return None;
837 }
838
839 void TextTrackCue::setCueSettings(const String& input)
840 {
841     m_settings = input;
842     unsigned position = 0;
843
844     while (position < input.length()) {
845
846         // The WebVTT cue settings part of a WebVTT cue consists of zero or more of the following components, in any order, 
847         // separated from each other by one or more U+0020 SPACE characters or U+0009 CHARACTER TABULATION (tab) characters. 
848         while (position < input.length() && WebVTTParser::isValidSettingDelimiter(input[position]))
849             position++;
850         if (position >= input.length())
851             break;
852
853         // When the user agent is to parse the WebVTT settings given by a string input for a text track cue cue, 
854         // the user agent must run the following steps:
855         // 1. Let settings be the result of splitting input on spaces.
856         // 2. For each token setting in the list settings, run the following substeps:
857         //    1. If setting does not contain a U+003A COLON character (:), or if the first U+003A COLON character (:) 
858         //       in setting is either the first or last character of setting, then jump to the step labeled next setting.
859         unsigned endOfSetting = position;
860         String setting = WebVTTParser::collectWord(input, &endOfSetting);
861         CueSetting name;
862         size_t colonOffset = setting.find(':', 1);
863         if (colonOffset == notFound || colonOffset == 0 || colonOffset == setting.length() - 1)
864             goto NextSetting;
865
866         // 2. Let name be the leading substring of setting up to and excluding the first U+003A COLON character (:) in that string.
867         name = settingName(setting.substring(0, colonOffset));
868
869         // 3. Let value be the trailing substring of setting starting from the character immediately after the first U+003A COLON character (:) in that string.
870         position += colonOffset + 1;
871         if (position >= input.length())
872             break;
873
874         // 4. Run the appropriate substeps that apply for the value of name, as follows:
875         switch (name) {
876         case Vertical:
877             {
878             // If name is a case-sensitive match for "vertical"
879             // 1. If value is a case-sensitive match for the string "rl", then let cue's text track cue writing direction 
880             //    be vertical growing left.
881             String writingDirection = WebVTTParser::collectWord(input, &position);
882             if (writingDirection == verticalGrowingLeftKeyword())
883                 m_writingDirection = VerticalGrowingLeft;
884             
885             // 2. Otherwise, if value is a case-sensitive match for the string "lr", then let cue's text track cue writing 
886             //    direction be vertical growing right.
887             else if (writingDirection == verticalGrowingRightKeyword())
888                 m_writingDirection = VerticalGrowingRight;
889             }
890             break;
891         case Line:
892             {
893             // 1-2 - Collect chars that are either '-', '%', or a digit.
894             // 1. If value contains any characters other than U+002D HYPHEN-MINUS characters (-), U+0025 PERCENT SIGN 
895             //    characters (%), and characters in the range U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9), then jump
896             //    to the step labeled next setting.
897             StringBuilder linePositionBuilder;
898             while (position < input.length() && (input[position] == '-' || input[position] == '%' || isASCIIDigit(input[position])))
899                 linePositionBuilder.append(input[position++]);
900             if (position < input.length() && !WebVTTParser::isValidSettingDelimiter(input[position]))
901                 break;
902
903             // 2. If value does not contain at least one character in the range U+0030 DIGIT ZERO (0) to U+0039 DIGIT 
904             //    NINE (9), then jump to the step labeled next setting.
905             // 3. If any character in value other than the first character is a U+002D HYPHEN-MINUS character (-), then 
906             //    jump to the step labeled next setting.
907             // 4. If any character in value other than the last character is a U+0025 PERCENT SIGN character (%), then
908             //    jump to the step labeled next setting.
909             String linePosition = linePositionBuilder.toString();
910             if (linePosition.find('-', 1) != notFound || linePosition.reverseFind("%", linePosition.length() - 2) != notFound)
911                 break;
912
913             // 5. If the first character in value is a U+002D HYPHEN-MINUS character (-) and the last character in value is a 
914             //    U+0025 PERCENT SIGN character (%), then jump to the step labeled next setting.
915             if (linePosition[0] == '-' && linePosition[linePosition.length() - 1] == '%')
916                 break;
917
918             // 6. Ignoring the trailing percent sign, if any, interpret value as a (potentially signed) integer, and 
919             //    let number be that number. 
920             // NOTE: toInt ignores trailing non-digit characters, such as '%'.
921             bool validNumber;
922             int number = linePosition.toInt(&validNumber);
923             if (!validNumber)
924                 break;
925
926             // 7. If the last character in value is a U+0025 PERCENT SIGN character (%), but number is not in the range 
927             //    0 ≤ number ≤ 100, then jump to the step labeled next setting.
928             // 8. Let cue's text track cue line position be number.
929             // 9. If the last character in value is a U+0025 PERCENT SIGN character (%), then let cue's text track cue 
930             //    snap-to-lines flag be false. Otherwise, let it be true.
931             if (linePosition[linePosition.length() - 1] == '%') {
932                 if (number < 0 || number > 100)
933                     break;
934
935                 // 10 - If '%' then set snap-to-lines flag to false.
936                 m_snapToLines = false;
937             }
938
939             m_linePosition = number;
940             }
941             break;
942         case Position:
943             {
944             // 1. If value contains any characters other than U+0025 PERCENT SIGN characters (%) and characters in the range 
945             //    U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9), then jump to the step labeled next setting.
946             // 2. If value does not contain at least one character in the range U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9),
947             //    then jump to the step labeled next setting.
948             String textPosition = WebVTTParser::collectDigits(input, &position);
949             if (textPosition.isEmpty())
950                 break;
951             if (position >= input.length())
952                 break;
953
954             // 3. If any character in value other than the last character is a U+0025 PERCENT SIGN character (%), then jump
955             //    to the step labeled next setting.
956             // 4. If the last character in value is not a U+0025 PERCENT SIGN character (%), then jump to the step labeled
957             //    next setting.
958             if (input[position++] != '%')
959                 break;
960             if (position < input.length() && !WebVTTParser::isValidSettingDelimiter(input[position]))
961                 break;
962
963             // 5. Ignoring the trailing percent sign, interpret value as an integer, and let number be that number.
964             // 6. If number is not in the range 0 ≤ number ≤ 100, then jump to the step labeled next setting.
965             // NOTE: toInt ignores trailing non-digit characters, such as '%'.
966             bool validNumber;
967             int number = textPosition.toInt(&validNumber);
968             if (!validNumber)
969                 break;
970             if (number < 0 || number > 100)
971               break;
972
973             // 7. Let cue's text track cue text position be number.
974             m_textPosition = number;
975             }
976             break;
977         case Size:
978             {
979             // 1. If value contains any characters other than U+0025 PERCENT SIGN characters (%) and characters in the
980             //    range U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9), then jump to the step labeled next setting.
981             // 2. If value does not contain at least one character in the range U+0030 DIGIT ZERO (0) to U+0039 DIGIT 
982             //    NINE (9), then jump to the step labeled next setting.
983             String cueSize = WebVTTParser::collectDigits(input, &position);
984             if (cueSize.isEmpty())
985                 break;
986             if (position >= input.length())
987                 break;
988
989             // 3. If any character in value other than the last character is a U+0025 PERCENT SIGN character (%),
990             //    then jump to the step labeled next setting.
991             // 4. If the last character in value is not a U+0025 PERCENT SIGN character (%), then jump to the step
992             //    labeled next setting.
993             if (input[position++] != '%')
994                 break;
995             if (position < input.length() && !WebVTTParser::isValidSettingDelimiter(input[position]))
996                 break;
997
998             // 5. Ignoring the trailing percent sign, interpret value as an integer, and let number be that number.
999             // 6. If number is not in the range 0 ≤ number ≤ 100, then jump to the step labeled next setting.
1000             bool validNumber;
1001             int number = cueSize.toInt(&validNumber);
1002             if (!validNumber)
1003                 break;
1004             if (number < 0 || number > 100)
1005                 break;
1006
1007             // 7. Let cue's text track cue size be number.
1008             m_cueSize = number;
1009             }
1010             break;
1011         case Align:
1012             {
1013             String cueAlignment = WebVTTParser::collectWord(input, &position);
1014
1015             // 1. If value is a case-sensitive match for the string "start", then let cue's text track cue alignment be start alignment.
1016             if (cueAlignment == startKeyword())
1017                 m_cueAlignment = Start;
1018
1019             // 2. If value is a case-sensitive match for the string "middle", then let cue's text track cue alignment be middle alignment.
1020             else if (cueAlignment == middleKeyword())
1021                 m_cueAlignment = Middle;
1022
1023             // 3. If value is a case-sensitive match for the string "end", then let cue's text track cue alignment be end alignment.
1024             else if (cueAlignment == endKeyword())
1025                 m_cueAlignment = End;
1026             }
1027             break;
1028         case None:
1029             break;
1030         }
1031
1032 NextSetting:
1033         position = endOfSetting;
1034     }
1035 }
1036
1037 int TextTrackCue::getCSSWritingMode() const
1038 {
1039     return m_displayWritingMode;
1040 }
1041
1042 int TextTrackCue::getCSSSize() const
1043 {
1044     return m_displaySize;
1045 }
1046
1047 std::pair<double, double> TextTrackCue::getCSSPosition() const
1048 {
1049     if (!m_snapToLines)
1050         return getPositionCoordinates();
1051
1052     return m_displayPosition;
1053 }
1054
1055 const AtomicString& TextTrackCue::interfaceName() const
1056 {
1057     return eventNames().interfaceForTextTrackCue;
1058 }
1059
1060 ScriptExecutionContext* TextTrackCue::scriptExecutionContext() const
1061 {
1062     return m_scriptExecutionContext;
1063 }
1064
1065 EventTargetData* TextTrackCue::eventTargetData()
1066 {
1067     return &m_eventTargetData;
1068 }
1069
1070 EventTargetData* TextTrackCue::ensureEventTargetData()
1071 {
1072     return &m_eventTargetData;
1073 }
1074
1075 bool TextTrackCue::operator==(const TextTrackCue& cue) const
1076 {
1077     if (cueType() != cue.cueType())
1078         return false;
1079
1080     if (m_endTime != cue.endTime())
1081         return false;
1082     if (m_startTime != cue.startTime())
1083         return false;
1084     if (m_content != cue.text())
1085         return false;
1086     if (m_settings != cue.cueSettings())
1087         return false;
1088     if (m_id != cue.id())
1089         return false;
1090     if (m_textPosition != cue.position())
1091         return false;
1092     if (m_linePosition != cue.line())
1093         return false;
1094     if (m_cueSize != cue.size())
1095         return false;
1096     if (align() != cue.align())
1097         return false;
1098     
1099     return true;
1100 }
1101
1102 } // namespace WebCore
1103
1104 #endif