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