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