VTTCue: Support 'auto' for line

Source/core/html/track/vtt/VTTCue.cpp

 /*
  * Copyright (c) 2013, Opera Software ASA. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 14 matching lines @@
  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  * OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/html/track/vtt/VTTCue.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
+#include "bindings/core/v8/UnionTypesCore.h"
 #include "core/CSSPropertyNames.h"
 #include "core/CSSValueKeywords.h"
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/events/Event.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLDivElement.h"
 #include "core/html/track/TextTrack.h"
 #include "core/html/track/TextTrackCueList.h"
 #include "core/html/track/vtt/VTTElement.h"
 #include "core/html/track/vtt/VTTParser.h"
 #include "core/html/track/vtt/VTTRegionList.h"
 #include "core/html/track/vtt/VTTScanner.h"
 #include "core/rendering/RenderVTTCue.h"
 #include "platform/FloatConversion.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/text/BidiResolver.h"
 #include "platform/text/TextRunIterator.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
-static const float undefinedPosition = -1;
 static const float undefinedSize = -1;
 
 static const CSSValueID displayWritingModeMap[] = {
     CSSValueHorizontalTb, CSSValueVerticalRl, CSSValueVerticalLr
 };
 static_assert(WTF_ARRAY_LENGTH(displayWritingModeMap) == VTTCue::NumberOfWritingDirections,
     "displayWritingModeMap should have the same number of elements as VTTCue::NumberOfWritingDirections");
 
 static const CSSValueID displayAlignmentMap[] = {
     CSSValueStart, CSSValueCenter, CSSValueEnd, CSSValueLeft, CSSValueRight
 };
 static_assert(WTF_ARRAY_LENGTH(displayAlignmentMap) == VTTCue::NumberOfAlignments,
     "displayAlignmentMap should have the same number of elements as VTTCue::NumberOfAlignments");
 
+static const String& autoKeyword()
+{
+    DEFINE_STATIC_LOCAL(const String, autoString, ("auto"));
+    return autoString;
+}
+
 static const String& startKeyword()
 {
     DEFINE_STATIC_LOCAL(const String, start, ("start"));
     return start;
 }
 
 static const String& middleKeyword()
 {
     DEFINE_STATIC_LOCAL(const String, middle, ("middle"));
     return middle;
@@ skipping 27 matching lines @@
     DEFINE_STATIC_LOCAL(const String, verticalrl, ("rl"));
     return verticalrl;
 }
 
 static const String& verticalGrowingRightKeyword()
 {
     DEFINE_STATIC_LOCAL(const String, verticallr, ("lr"));
     return verticallr;
 }
 
+static bool isInvalidPercentage(double value)
+{
+    ASSERT(std::isfinite(value));
+    return value < 0 || value > 100;
+}
+
 static bool isInvalidPercentage(double value, ExceptionState& exceptionState)
 {
-    ASSERT(std::isfinite(value));
-    if (value < 0 || value > 100) {
+    if (isInvalidPercentage(value)) {
         exceptionState.throwDOMException(IndexSizeError, ExceptionMessages::indexOutsideRange<double>("value", value, 0, ExceptionMessages::InclusiveBound, 100, ExceptionMessages::InclusiveBound));
         return true;
     }
     return false;
 }
 
 VTTCueBox::VTTCueBox(Document& document, VTTCue* cue)
     : HTMLDivElement(document)
     , m_cue(cue)
 {
@@ skipping 70 matching lines @@
 
 void VTTCueBox::trace(Visitor* visitor)
 {
     visitor->trace(m_cue);
     HTMLDivElement::trace(visitor);
 }
 
 VTTCue::VTTCue(Document& document, double startTime, double endTime, const String& text)
     : TextTrackCue(startTime, endTime)
     , m_text(text)
-    , m_linePosition(undefinedPosition)
-    , m_computedLinePosition(undefinedPosition)
+    , m_linePosition(std::numeric_limits<float>::quiet_NaN())
+    , m_computedLinePosition(std::numeric_limits<float>::quiet_NaN())
     , m_textPosition(50)
     , m_cueSize(100)
     , m_writingDirection(Horizontal)
     , m_cueAlignment(Middle)
     , m_vttNodeTree(nullptr)
     , m_cueBackgroundBox(HTMLDivElement::create(document))
     , m_displayDirection(CSSValueLtr)
     , m_displaySize(undefinedSize)
     , m_snapToLines(true)
     , m_displayTreeShouldChange(true)
@@ skipping 73 matching lines @@
 void VTTCue::setSnapToLines(bool value)
 {
     if (m_snapToLines == value)
         return;
 
     cueWillChange();
     m_snapToLines = value;
     cueDidChange();
 }
 
-void VTTCue::setLine(double position, ExceptionState& exceptionState)
+bool VTTCue::lineIsAuto() const
 {
-    // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-line
-    // On setting, if the text track cue snap-to-lines flag is not set, and the new
-    // value is negative or greater than 100, then throw an IndexSizeError exception.
-    if (!m_snapToLines && (position < 0 || position > 100)) {
-        exceptionState.throwDOMException(IndexSizeError, "The snap-to-lines flag is not set, and the value provided (" + String::number(position) + ") is not between 0 and 100.");
+    return std::isnan(m_linePosition);
+}
+
+void VTTCue::line(DoubleOrAutoKeyword& result) const
+{
+    if (lineIsAuto())
+        result.setAutoKeyword(autoKeyword());
+    else
+        result.setDouble(m_linePosition);
+}
+
+void VTTCue::setLine(const DoubleOrAutoKeyword& position, ExceptionState& exceptionState)
+{
+    // FIXME: Expecting bindings code to handle this case: https://crbug.com/450252.
+    if (position.isDouble() && !std::isfinite(position.getAsDouble())) {
+        exceptionState.throwTypeError("The provided double value is non-finite.");
         return;
     }
 
-    // Otherwise, set the text track cue line position to the new value.
-    float floatPosition = narrowPrecisionToFloat(position);
-    if (m_linePosition == floatPosition)
-        return;
+    // http://dev.w3.org/html5/webvtt/#dfn-vttcue-line
+    // On setting, the text track cue line position must be set to the new
+    // value; if the new value is the string "auto", then it must be
+    // interpreted as the special value auto.
+    // ("auto" is translated to NaN.)
+    float floatPosition;
+    if (position.isAutoKeyword()) {
+        if (lineIsAuto())
+            return;
+        floatPosition = std::numeric_limits<float>::quiet_NaN();
+    } else {
+        ASSERT(position.isDouble());
+        floatPosition = narrowPrecisionToFloat(position.getAsDouble());
+        if (m_linePosition == floatPosition)
+            return;
+    }
 
     cueWillChange();
     m_linePosition = floatPosition;
     m_computedLinePosition = calculateComputedLinePosition();
     cueDidChange();
 }
 
 void VTTCue::setPosition(double position, ExceptionState& exceptionState)
 {
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-position
@@ skipping 132 matching lines @@
     cueDidChange();
 }
 
 void VTTCue::notifyRegionWhenRemovingDisplayTree(bool notifyRegion)
 {
     m_notifyRegion = notifyRegion;
 }
 
 float VTTCue::calculateComputedLinePosition()
 {
-    // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#text-track-cue-computed-line-position
+    // http://dev.w3.org/html5/webvtt/#dfn-text-track-cue-computed-line-position
+    // A text track cue has a text track cue computed line position whose value
+    // is that returned by the following algorithm, which is defined in terms
+    // of the other aspects of the cue:
 
-    // If the text track cue line position is numeric, then that is the text
-    // track cue computed line position.
-    if (m_linePosition != undefinedPosition)
+    // 1. If the text track cue line position is numeric, the text track cue
+    //    snap-to-lines flag of the text track cue is not set, and the text
+    //    track cue line position is negative or greater than 100, then return
+    //    100 and abort these steps.
+    if (!lineIsAuto() && !m_snapToLines && isInvalidPercentage(m_linePosition))
+        return 100;
+
+    // 2. If the text track cue line position is numeric, return the value of
+    //    the text track cue line position and abort these steps. (Either the
+    //    text track cue snap-to-lines flag is set, so any value, not just
+    //    those in the range 0..100, is valid, or the value is in the range
+    //    0..100 and is thus valid regardless of the value of that flag.)
+    if (!lineIsAuto())
         return m_linePosition;
 
-    // If the text track cue snap-to-lines flag of the text track cue is not
-    // set, the text track cue computed line position is the value 100;
+    // 3. If the text track cue snap-to-lines flag of the text track cue is not
+    //    set, return the value 100 and abort these steps. (The text track cue
+    //    line position is the special value auto.)
     if (!m_snapToLines)
         return 100;
 
-    // Otherwise, it is the value returned by the following algorithm:
-
-    // If cue is not associated with a text track, return -1 and abort these
-    // steps.
+    // 4. Let cue be the text track cue.
+    // 5. If cue is not in a list of cues of a text track, or if that text
+    //    track is not in the list of text tracks of a media element, return -1
+    //    and abort these steps.
     if (!track())
         return -1;
 
-    // Let n be the number of text tracks whose text track mode is showing or
-    // showing by default and that are in the media element's list of text
-    // tracks before track.
+    // 6. Let track be the text track whose list of cues the cue is in.
+    // 7. Let n be the number of text tracks whose text track mode is showing
+    //    and that are in the media element's list of text tracks before track.
     int n = track()->trackIndexRelativeToRenderedTracks();
 
-    // Increment n by one.
+    // 8. Increment n by one. / 9. Negate n. / 10. Return n.
     n++;
-
-    // Negate n.
     n = -n;
-
     return n;
 }
 
 class VTTTextRunIterator : public TextRunIterator {
 public:
     VTTTextRunIterator() { }
     VTTTextRunIterator(const TextRun* textRun, unsigned offset) : TextRunIterator(textRun, offset) { }
 
     bool atParagraphSeparator() const
     {
@@ skipping 266 matching lines @@
 void VTTCue::updateDisplay(const IntSize& videoSize, HTMLDivElement& container)
 {
     UseCounter::count(document(), UseCounter::VTTCueRender);
 
     if (m_writingDirection != Horizontal)
         UseCounter::count(document(), UseCounter::VTTCueRenderVertical);
 
     if (!m_snapToLines)
         UseCounter::count(document(), UseCounter::VTTCueRenderSnapToLinesFalse);
 
-    if (m_linePosition != undefinedPosition)
+    if (!lineIsAuto())
         UseCounter::count(document(), UseCounter::VTTCueRenderLineNotAuto);
 
     if (m_textPosition != 50)
         UseCounter::count(document(), UseCounter::VTTCueRenderPositionNot50);
 
     if (m_cueSize != 100)
         UseCounter::count(document(), UseCounter::VTTCueRenderSizeNot100);
 
     if (m_cueAlignment != Middle)
         UseCounter::count(document(), UseCounter::VTTCueRenderAlignNotMiddle);
@@ skipping 20 matching lines @@
         if (!container.contains(regionNode.get()))
             container.appendChild(regionNode);
 
         region->appendVTTCueBox(displayBox);
     }
 }
 
 FloatPoint VTTCue::getPositionCoordinates() const
 {
     // This method is used for setting x and y when snap to lines is not set.
+    ASSERT(std::isfinite(m_computedLinePosition));
 
     if (m_writingDirection == Horizontal && m_displayDirection == CSSValueLtr)
         return FloatPoint(m_textPosition, m_computedLinePosition);
 
     if (m_writingDirection == Horizontal && m_displayDirection == CSSValueRtl)
         return FloatPoint(100 - m_textPosition, m_computedLinePosition);
 
     if (m_writingDirection == VerticalGrowingLeft)
         return FloatPoint(100 - m_computedLinePosition, m_textPosition);
 
@@ skipping 189 matching lines @@
         // Make sure the entire run is consumed.
         input.skipRun(valueRun);
     }
 
     // If cue's line position is not auto or cue's size is not 100 or cue's
     // writing direction is not horizontal, but cue's region identifier is not
     // the empty string, let cue's region identifier be the empty string.
     if (m_regionId.isEmpty())
         return;
 
-    if (m_linePosition != undefinedPosition || m_cueSize != 100 || m_writingDirection != Horizontal)
+    if (!lineIsAuto() || m_cueSize != 100 || m_writingDirection != Horizontal)
         m_regionId = emptyString();
 }
 
 CSSValueID VTTCue::getCSSAlignment() const
 {
     return displayAlignmentMap[m_cueAlignment];
 }
 
 CSSValueID VTTCue::getCSSWritingDirection() const
 {
@@ skipping 33 matching lines @@
 
 void VTTCue::trace(Visitor* visitor)
 {
     visitor->trace(m_vttNodeTree);
     visitor->trace(m_cueBackgroundBox);
     visitor->trace(m_displayTree);
     TextTrackCue::trace(visitor);
 }
 
 } // namespace blink