VTTCue: Make position/line/size double attributes

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 28 matching lines @@
 #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 int undefinedPosition = -1;
-static const int undefinedSize = -1;
+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
 };
@@ skipping 40 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(int value, ExceptionState& exceptionState)
+static bool isInvalidPercentage(double value, ExceptionState& exceptionState)
 {
+    ASSERT(std::isfinite(value));
     if (value < 0 || value > 100) {
-        exceptionState.throwDOMException(IndexSizeError, ExceptionMessages::indexOutsideRange("value", value, 0, ExceptionMessages::InclusiveBound, 100, ExceptionMessages::InclusiveBound));
+        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)
 {
     setShadowPseudoId(AtomicString("-webkit-media-text-track-display", AtomicString::ConstructFromLiteral));
@@ skipping 164 matching lines @@
 void VTTCue::setSnapToLines(bool value)
 {
     if (m_snapToLines == value)
         return;
 
     cueWillChange();
     m_snapToLines = value;
     cueDidChange();
 }
 
-void VTTCue::setLine(int position, ExceptionState& exceptionState)
+void VTTCue::setLine(double position, ExceptionState& exceptionState)
 {
     // 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;
     }
 
     // Otherwise, set the text track cue line position to the new value.
-    if (m_linePosition == position)
+    float floatPosition = narrowPrecisionToFloat(position);
+    if (m_linePosition == floatPosition)
         return;
 
     cueWillChange();
-    m_linePosition = position;
+    m_linePosition = floatPosition;
     m_computedLinePosition = calculateComputedLinePosition();
     cueDidChange();
 }
 
-void VTTCue::setPosition(int position, ExceptionState& exceptionState)
+void VTTCue::setPosition(double position, ExceptionState& exceptionState)
 {
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-position
     // On setting, if the new value is negative or greater than 100, then throw an IndexSizeError exception.
     // Otherwise, set the text track cue text position to the new value.
     if (isInvalidPercentage(position, exceptionState))
         return;
 
     // Otherwise, set the text track cue line position to the new value.
-    if (m_textPosition == position)
+    float floatPosition = narrowPrecisionToFloat(position);
+    if (m_textPosition == floatPosition)
         return;
 
     cueWillChange();
-    m_textPosition = position;
+    m_textPosition = floatPosition;
     cueDidChange();
 }
 
-void VTTCue::setSize(int size, ExceptionState& exceptionState)
+void VTTCue::setSize(double size, ExceptionState& exceptionState)
 {
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#dom-texttrackcue-size
     // On setting, if the new value is negative or greater than 100, then throw an IndexSizeError
     // exception. Otherwise, set the text track cue size to the new value.
     if (isInvalidPercentage(size, exceptionState))
         return;
 
     // Otherwise, set the text track cue line position to the new value.
-    if (m_cueSize == size)
+    float floatSize = narrowPrecisionToFloat(size);
+    if (m_cueSize == floatSize)
         return;
 
     cueWillChange();
-    m_cueSize = size;
+    m_cueSize = floatSize;
     cueDidChange();
 }
 
 const String& VTTCue::align() const
 {
     switch (m_cueAlignment) {
     case Start:
         return startKeyword();
     case Middle:
         return middleKeyword();
@@ skipping 90 matching lines @@
     cueWillChange();
     m_regionId = regionId;
     cueDidChange();
 }
 
 void VTTCue::notifyRegionWhenRemovingDisplayTree(bool notifyRegion)
 {
     m_notifyRegion = notifyRegion;
 }
 
-int VTTCue::calculateComputedLinePosition()
+float VTTCue::calculateComputedLinePosition()
 {
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-video-element.html#text-track-cue-computed-line-position
 
     // If the text track cue line position is numeric, then that is the text
     // track cue computed line position.
     if (m_linePosition != undefinedPosition)
         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;
@@ skipping 101 matching lines @@
     // 10.4 If the text track cue writing direction is horizontal, then let
     // block-flow be 'tb'. Otherwise, if the text track cue writing direction is
     // vertical growing left, then let block-flow be 'lr'. Otherwise, the text
     // track cue writing direction is vertical growing right; let block-flow be
     // 'rl'.
 
     // The above step is done through the writing direction static map.
 
     // 10.5 Determine the value of maximum size for cue as per the appropriate
     // rules from the following list:
-    int maximumSize = m_textPosition;
+    float maximumSize = m_textPosition;
     if ((m_writingDirection == Horizontal && m_cueAlignment == Start && m_displayDirection == CSSValueLtr)
         || (m_writingDirection == Horizontal && m_cueAlignment == End && m_displayDirection == CSSValueRtl)
         || (m_writingDirection == Horizontal && m_cueAlignment == Left)
         || (m_writingDirection == VerticalGrowingLeft && (m_cueAlignment == Start || m_cueAlignment == Left))
         || (m_writingDirection == VerticalGrowingRight && (m_cueAlignment == Start || m_cueAlignment == Left))) {
         maximumSize = 100 - m_textPosition;
     } else if ((m_writingDirection == Horizontal && m_cueAlignment == End && m_displayDirection == CSSValueLtr)
         || (m_writingDirection == Horizontal && m_cueAlignment == Start && m_displayDirection == CSSValueRtl)
         || (m_writingDirection == Horizontal && m_cueAlignment == Right)
         || (m_writingDirection == VerticalGrowingLeft && (m_cueAlignment == End || m_cueAlignment == Right))
         || (m_writingDirection == VerticalGrowingRight && (m_cueAlignment == End || m_cueAlignment == Right))) {
         maximumSize = m_textPosition;
     } else if (m_cueAlignment == Middle) {
         maximumSize = m_textPosition <= 50 ? m_textPosition : (100 - m_textPosition);
         maximumSize = maximumSize * 2;
     } else {
         ASSERT_NOT_REACHED();
     }
 
     // 10.6 If the text track cue size is less than maximum size, then let size
     // be text track cue size. Otherwise, let size be maximum size.
     m_displaySize = std::min(m_cueSize, maximumSize);
 
     // FIXME: Understand why step 10.7 is missing (just a copy/paste error?)
     // Could be done within a spec implementation check - http://crbug.com/301580
 
     // 10.8 Determine the value of x-position or y-position for cue as per the
     // appropriate rules from the following list:
     if (m_writingDirection == Horizontal) {
-        int visualTextPosition = m_displayDirection == CSSValueLtr ? m_textPosition : 100 - m_textPosition;
+        float visualTextPosition = m_displayDirection == CSSValueLtr ? m_textPosition : 100 - m_textPosition;
 
         switch (resolveCueAlignment(m_cueAlignment, m_displayDirection)) {
         case Left:
             m_displayPosition.setX(visualTextPosition);
             break;
         case Right:
             m_displayPosition.setX(visualTextPosition - m_displaySize);
             break;
         case Middle:
             m_displayPosition.setX(visualTextPosition - m_displaySize / 2);
@@ skipping 414 matching lines @@
 CSSValueID VTTCue::getCSSWritingDirection() const
 {
     return m_displayDirection;
 }
 
 CSSValueID VTTCue::getCSSWritingMode() const
 {
     return displayWritingModeMap[m_writingDirection];
 }
 
-int VTTCue::getCSSSize() const
+float VTTCue::getCSSSize() const
 {
     ASSERT(m_displaySize != undefinedSize);
     return m_displaySize;
 }
 
 FloatPoint VTTCue::getCSSPosition() const
 {
     if (!m_snapToLines)
         return getPositionCoordinates();
 
@@ skipping 14 matching lines @@
 
 void VTTCue::trace(Visitor* visitor)
 {
     visitor->trace(m_vttNodeTree);
     visitor->trace(m_cueBackgroundBox);
     visitor->trace(m_displayTree);
     TextTrackCue::trace(visitor);
 }
 
 } // namespace blink