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