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