VTTCue: Refactor display parameter handling

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 125 matching lines @@
     return false;
 }
 
 VTTCueBox::VTTCueBox(Document& document, VTTCue* cue)
     : HTMLDivElement(document)
     , m_cue(cue)
 {
     setShadowPseudoId(AtomicString("-webkit-media-text-track-display", AtomicString::ConstructFromLiteral));
 }
 
-void VTTCueBox::applyCSSProperties(const IntSize&)
+void VTTCueBox::applyCSSProperties(const VTTDisplayParameters& displayParameters)
 {
     // FIXME: Apply all the initial CSS positioning properties. http://wkb.ug/79916
     if (!m_cue->regionId().isEmpty()) {
         setInlineStyleProperty(CSSPropertyPosition, CSSValueRelative);
         return;
     }
 
     // 3.5.1 On the (root) List of WebVTT Node Objects:
 
     // the 'position' property must be set to 'absolute'
     setInlineStyleProperty(CSSPropertyPosition, CSSValueAbsolute);
 
     //  the 'unicode-bidi' property must be set to 'plaintext'
     setInlineStyleProperty(CSSPropertyUnicodeBidi, CSSValueWebkitPlaintext);
 
     // the 'direction' property must be set to direction
-    setInlineStyleProperty(CSSPropertyDirection, m_cue->getCSSWritingDirection());
+    setInlineStyleProperty(CSSPropertyDirection, displayParameters.direction);
 
     // the 'writing-mode' property must be set to writing-mode
-    setInlineStyleProperty(CSSPropertyWebkitWritingMode, m_cue->getCSSWritingMode());
+    setInlineStyleProperty(CSSPropertyWebkitWritingMode, displayParameters.writingMode);
 
-    FloatPoint position = m_cue->getCSSPosition();
+    const FloatPoint& position = displayParameters.position;
 
     // the 'top' property must be set to top,
     setInlineStyleProperty(CSSPropertyTop, position.y(), CSSPrimitiveValue::CSS_PERCENTAGE);
 
     // the 'left' property must be set to left
     setInlineStyleProperty(CSSPropertyLeft, position.x(), CSSPrimitiveValue::CSS_PERCENTAGE);
 
     // the 'width' property must be set to width, and the 'height' property  must be set to height
     if (m_cue->vertical() == horizontalKeyword()) {
-        setInlineStyleProperty(CSSPropertyWidth, static_cast<double>(m_cue->getCSSSize()), CSSPrimitiveValue::CSS_PERCENTAGE);
+        setInlineStyleProperty(CSSPropertyWidth, displayParameters.size, CSSPrimitiveValue::CSS_PERCENTAGE);
         setInlineStyleProperty(CSSPropertyHeight, CSSValueAuto);
     } else {
         setInlineStyleProperty(CSSPropertyWidth, CSSValueAuto);
-        setInlineStyleProperty(CSSPropertyHeight, static_cast<double>(m_cue->getCSSSize()),  CSSPrimitiveValue::CSS_PERCENTAGE);
+        setInlineStyleProperty(CSSPropertyHeight, displayParameters.size,  CSSPrimitiveValue::CSS_PERCENTAGE);
     }
 
     // The 'text-align' property on the (root) List of WebVTT Node Objects must
     // be set to the value in the second cell of the row of the table below
     // whose first cell is the value of the corresponding cue's text track cue
     // alignment:
-    setInlineStyleProperty(CSSPropertyTextAlign, m_cue->getCSSAlignment());
+    setInlineStyleProperty(CSSPropertyTextAlign, displayAlignmentMap[m_cue->cueAlignment()]);
 
     if (!m_cue->snapToLines()) {
         // 10.13.1 Set up x and y:
         // Note: x and y are set through the CSS left and top above.
 
         // 10.13.2 Position the boxes in boxes such that the point x% along the
         // width of the bounding box of the boxes in boxes is x% of the way
         // across the width of the video's rendering area, and the point y%
         // along the height of the bounding box of the boxes in boxes is y%
         // of the way across the height of the video's rendering area, while
@@ skipping 14 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(std::numeric_limits<float>::quiet_NaN())
-    , m_computedLinePosition(std::numeric_limits<float>::quiet_NaN())
     , m_textPosition(std::numeric_limits<float>::quiet_NaN())
     , m_cueSize(100)
     , m_writingDirection(Horizontal)
     , m_cueAlignment(Middle)
     , m_vttNodeTree(nullptr)
     , m_cueBackgroundBox(HTMLDivElement::create(document))
-    , m_displayDirection(CSSValueLtr)
-    , m_displaySize(std::numeric_limits<float>::quiet_NaN())
     , m_snapToLines(true)
     , m_displayTreeShouldChange(true)
     , m_notifyRegion(true)
 {
     UseCounter::count(document, UseCounter::VTTCue);
 }
 
 VTTCue::~VTTCue()
 {
     // Using oilpan, if m_displayTree is in the document it will strongly keep
@@ skipping 105 matching lines @@
         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();
 }
 
 bool VTTCue::textPositionIsAuto() const
 {
     return std::isnan(m_textPosition);
 }
 
 void VTTCue::position(DoubleOrAutoKeyword& result) const
 {
@@ skipping 153 matching lines @@
     cueWillChange();
     m_regionId = regionId;
     cueDidChange();
 }
 
 void VTTCue::notifyRegionWhenRemovingDisplayTree(bool notifyRegion)
 {
     m_notifyRegion = notifyRegion;
 }
 
-float VTTCue::calculateComputedLinePosition()
+float VTTCue::calculateComputedLinePosition() const
 {
     // 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:
 
     // 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.
@@ skipping 119 matching lines @@
     switch (m_cueAlignment) {
     case VTTCue::Left:
         return VTTCue::Start;
     case VTTCue::Right:
         return VTTCue::End;
     default:
         return m_cueAlignment;
     }
 }
 
-void VTTCue::calculateDisplayParameters()
+VTTDisplayParameters::VTTDisplayParameters()
+    : size(std::numeric_limits<float>::quiet_NaN())
+    , direction(CSSValueNone)
+    , writingMode(CSSValueNone) { }
+
+VTTDisplayParameters VTTCue::calculateDisplayParameters() const
 {
-    createVTTNodeTree();
-
     // http://dev.w3.org/html5/webvtt/#dfn-apply-webvtt-cue-settings
 
+    VTTDisplayParameters displayParameters;
     // Steps 1 and 2.
-    m_displayDirection = determineTextDirection(m_vttNodeTree.get());
+    displayParameters.direction = determineTextDirection(m_vttNodeTree.get());
 
-    if (m_displayDirection == CSSValueRtl)
+    if (displayParameters.direction == CSSValueRtl)
         UseCounter::count(document(), UseCounter::VTTCueRenderRtl);
 
     // 3. 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.
+    displayParameters.writingMode = displayWritingModeMap[m_writingDirection];
 
     // Resolve the cue alignment to one of the values {start, end, middle}.
     CueAlignment computedCueAlignment = calculateComputedCueAlignment();
 
     // 4. Determine the value of maximum size for cue as per the appropriate
     // rules from the following list:
     float computedTextPosition = calculateComputedTextPosition();
     float maximumSize = computedTextPosition;
     if (computedCueAlignment == Start) {
         maximumSize = 100 - computedTextPosition;
     } else if (computedCueAlignment == End) {
         maximumSize = computedTextPosition;
     } else if (computedCueAlignment == Middle) {
         maximumSize = computedTextPosition <= 50 ? computedTextPosition : (100 - computedTextPosition);
         maximumSize = maximumSize * 2;
     } else {
         ASSERT_NOT_REACHED();
     }
 
     // 5. 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);
+    displayParameters.size = std::min(m_cueSize, maximumSize);
 
     // 6. If the text track cue writing direction is horizontal, then let width
     // be 'size vw' and height be 'auto'. Otherwise, let width be 'auto' and
     // height be 'size vh'. (These are CSS values used by the next section to
     // set CSS properties for the rendering; 'vw' and 'vh' are CSS units.)
     // (Emulated in VTTCueBox::applyCSSProperties.)
 
     // 7. Determine the value of x-position or y-position for cue as per the
     // appropriate rules from the following list:
     if (m_writingDirection == Horizontal) {
         switch (computedCueAlignment) {
         case Start:
-            m_displayPosition.setX(computedTextPosition);
+            displayParameters.position.setX(computedTextPosition);
             break;
         case End:
-            m_displayPosition.setX(computedTextPosition - m_displaySize);
+            displayParameters.position.setX(computedTextPosition - displayParameters.size);
             break;
         case Middle:
-            m_displayPosition.setX(computedTextPosition - m_displaySize / 2);
+            displayParameters.position.setX(computedTextPosition - displayParameters.size / 2);
             break;
         default:
             ASSERT_NOT_REACHED();
         }
     } else {
         // Cases for m_writingDirection being VerticalGrowing{Left|Right}
         switch (computedCueAlignment) {
         case Start:
-            m_displayPosition.setY(computedTextPosition);
+            displayParameters.position.setY(computedTextPosition);
             break;
         case End:
-            m_displayPosition.setY(computedTextPosition - m_displaySize);
+            displayParameters.position.setY(computedTextPosition - displayParameters.size);
             break;
         case Middle:
-            m_displayPosition.setY(computedTextPosition - m_displaySize / 2);
+            displayParameters.position.setY(computedTextPosition - displayParameters.size / 2);
             break;
         default:
             ASSERT_NOT_REACHED();
         }
     }
 
     // A text track cue has a text track cue computed line position whose value
     // is defined in terms of the other aspects of the cue.
-    m_computedLinePosition = calculateComputedLinePosition();
+    float computedLinePosition = calculateComputedLinePosition();
 
     // 8. Determine the value of whichever of x-position or y-position is not
     // yet calculated for cue as per the appropriate rules from the following
     // list:
     if (!m_snapToLines) {
         if (m_writingDirection == Horizontal)
-            m_displayPosition.setY(m_computedLinePosition);
+            displayParameters.position.setY(computedLinePosition);
         else
-            m_displayPosition.setX(m_computedLinePosition);
+            displayParameters.position.setX(computedLinePosition);
     } else {
         if (m_writingDirection == Horizontal)
-            m_displayPosition.setY(0);
+            displayParameters.position.setY(0);
         else
-            m_displayPosition.setX(0);
+            displayParameters.position.setX(0);
     }
+
+    // FIXME: Remove this block.

[fs, 2015/01/22 17:43:21]

Kept this block (from getPositionCoordinates) around for now to try and avoid
any behavioral changes in this CL. Intend to remove it in a follow up (need to
figure out how to update the single test that's affected.)

[philipj_slow, 2015/01/26 03:00:16]

Acknowledged.

+    if (!m_snapToLines) {
+        if (m_writingDirection == Horizontal && displayParameters.direction == CSSValueLtr)
+            displayParameters.position.setX(computedTextPosition);
+
+        if (m_writingDirection == Horizontal && displayParameters.direction == CSSValueRtl)
+            displayParameters.position.setX(100 - computedTextPosition);
+
+        if (m_writingDirection == VerticalGrowingLeft)
+            displayParameters.position = FloatPoint(100 - computedLinePosition, computedTextPosition);
+
+        if (m_writingDirection == VerticalGrowingRight)
+            displayParameters.position.setY(computedTextPosition);
+    }
+
+    // Step 9 not implemented (margin == 0).
+
+    ASSERT(std::isfinite(displayParameters.size));
+    ASSERT(displayParameters.direction != CSSValueNone);
+    ASSERT(displayParameters.writingMode != CSSValueNone);
+    return displayParameters;
 }
 
 void VTTCue::markFutureAndPastNodes(ContainerNode* root, double previousTimestamp, double movieTime)
 {
     DEFINE_STATIC_LOCAL(const String, timestampTag, ("timestamp"));
 
     bool isPastNode = true;
     double currentTimestamp = previousTimestamp;
     if (currentTimestamp > movieTime)
         isPastNode = false;
@@ skipping 27 matching lines @@
 
     // Clear the contents of the set.
     m_cueBackgroundBox->removeChildren();
 
     // Update the two sets containing past and future WebVTT objects.
     RefPtrWillBeRawPtr<DocumentFragment> referenceTree = createCueRenderingTree();
     markFutureAndPastNodes(referenceTree.get(), startTime(), movieTime);
     m_cueBackgroundBox->appendChild(referenceTree, ASSERT_NO_EXCEPTION);
 }
 
-PassRefPtrWillBeRawPtr<VTTCueBox> VTTCue::getDisplayTree(const IntSize& videoSize)
+PassRefPtrWillBeRawPtr<VTTCueBox> VTTCue::getDisplayTree()
 {
     RefPtrWillBeRawPtr<VTTCueBox> displayTree(ensureDisplayTree());
     if (!m_displayTreeShouldChange || !track()->isRendered())
         return displayTree.release();
 
+    createVTTNodeTree();
+
     // 10.1 - 10.10
-    calculateDisplayParameters();
+    VTTDisplayParameters displayParameters = calculateDisplayParameters();
 
     // 10.11. Apply the terms of the CSS specifications to nodes within the
     // following constraints, thus obtaining a set of CSS boxes positioned
     // relative to an initial containing block:
     displayTree->removeChildren();
 
     // The document tree is the tree of WebVTT Node Objects rooted at nodes.
 
     // The children of the nodes must be wrapped in an anonymous box whose
     // 'display' property has the value 'inline'. This is the WebVTT cue
     // background box.
 
     // Note: This is contained by default in m_cueBackgroundBox.
     m_cueBackgroundBox->setShadowPseudoId(cueShadowPseudoId());
     displayTree->appendChild(m_cueBackgroundBox);
 
     // FIXME(BUG 79916): Runs of children of WebVTT Ruby Objects that are not
     // WebVTT Ruby Text Objects must be wrapped in anonymous boxes whose
     // 'display' property has the value 'ruby-base'.
 
     // FIXME(BUG 79916): Text runs must be wrapped according to the CSS
     // line-wrapping rules, except that additionally, regardless of the value of
     // the 'white-space' property, lines must be wrapped at the edge of their
     // containing blocks, even if doing so requires splitting a word where there
     // is no line breaking opportunity. (Thus, normally text wraps as needed,
     // but if there is a particularly long word, it does not overflow as it
     // normally would in CSS, it is instead forcibly wrapped at the box's edge.)
-    displayTree->applyCSSProperties(videoSize);
+    displayTree->applyCSSProperties(displayParameters);
 
     m_displayTreeShouldChange = false;
 
     // 10.15. Let cue's text track cue display state have the CSS boxes in
     // boxes.
     return displayTree.release();
 }
 
 void VTTCue::removeDisplayTree()
 {
     if (m_notifyRegion && track()->regions()) {
         // The region needs to be informed about the cue removal.
         VTTRegion* region = track()->regions()->getRegionById(m_regionId);
         if (region)
             region->willRemoveVTTCueBox(m_displayTree.get());
     }
 
     if (m_displayTree)
         m_displayTree->remove(ASSERT_NO_EXCEPTION);
 }
 
-void VTTCue::updateDisplay(const IntSize& videoSize, HTMLDivElement& container)
+void VTTCue::updateDisplay(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 (!lineIsAuto())
         UseCounter::count(document(), UseCounter::VTTCueRenderLineNotAuto);
 
     if (textPositionIsAuto())
         UseCounter::count(document(), UseCounter::VTTCueRenderPositionNot50);
 
     if (m_cueSize != 100)
         UseCounter::count(document(), UseCounter::VTTCueRenderSizeNot100);
 
     if (m_cueAlignment != Middle)
         UseCounter::count(document(), UseCounter::VTTCueRenderAlignNotMiddle);
 
-    RefPtrWillBeRawPtr<VTTCueBox> displayBox = getDisplayTree(videoSize);
+    RefPtrWillBeRawPtr<VTTCueBox> displayBox = getDisplayTree();
     VTTRegion* region = 0;
     if (track()->regions())
         region = track()->regions()->getRegionById(regionId());
 
     if (!region) {
         // If cue has an empty text track cue region identifier or there is no
         // WebVTT region whose region identifier is identical to cue's text
         // track cue region identifier, run the following substeps:
         if (displayBox->hasChildren() && !container.contains(displayBox.get())) {
             // Note: the display tree of a cue is removed when the active flag of the cue is unset.
             container.appendChild(displayBox);
         }
     } else {
         // Let region be the WebVTT region whose region identifier
         // matches the text track cue region identifier of cue.
         RefPtrWillBeRawPtr<HTMLDivElement> regionNode = region->getDisplayTree(document());
 
         // Append the region to the viewport, if it was not already.
         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));
-    float computedTextPosition = calculateComputedTextPosition();
-
-    if (m_writingDirection == Horizontal && m_displayDirection == CSSValueLtr)
-        return FloatPoint(computedTextPosition, m_computedLinePosition);
-
-    if (m_writingDirection == Horizontal && m_displayDirection == CSSValueRtl)
-        return FloatPoint(100 - computedTextPosition, m_computedLinePosition);
-
-    if (m_writingDirection == VerticalGrowingLeft)
-        return FloatPoint(100 - m_computedLinePosition, computedTextPosition);
-
-    if (m_writingDirection == VerticalGrowingRight)
-        return FloatPoint(m_computedLinePosition, computedTextPosition);
-
-    ASSERT_NOT_REACHED();
-    return FloatPoint();
-}
-
-VTTCue::CueSetting VTTCue::settingName(VTTScanner& input)
+VTTCue::CueSetting VTTCue::settingName(VTTScanner& input) const
 {
     CueSetting parsedSetting = None;
     if (input.scan("vertical"))
         parsedSetting = Vertical;
     else if (input.scan("line"))
         parsedSetting = Line;
     else if (input.scan("position"))
         parsedSetting = Position;
     else if (input.scan("size"))
         parsedSetting = Size;
@@ skipping 183 matching lines @@
     // 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 (!lineIsAuto() || m_cueSize != 100 || m_writingDirection != Horizontal)
         m_regionId = emptyString();
 }
 
-CSSValueID VTTCue::getCSSAlignment() const
-{
-    return displayAlignmentMap[m_cueAlignment];
-}
-
-CSSValueID VTTCue::getCSSWritingDirection() const
-{
-    return m_displayDirection;
-}
-
-CSSValueID VTTCue::getCSSWritingMode() const
-{
-    return displayWritingModeMap[m_writingDirection];
-}
-
-float VTTCue::getCSSSize() const
-{
-    ASSERT(std::isfinite(m_displaySize));
-    return m_displaySize;
-}
-
-FloatPoint VTTCue::getCSSPosition() const
-{
-    if (!m_snapToLines)
-        return getPositionCoordinates();
-
-    return m_displayPosition;
-}
-
 ExecutionContext* VTTCue::executionContext() const
 {
     ASSERT(m_cueBackgroundBox);
     return m_cueBackgroundBox->executionContext();
 }
 
 Document& VTTCue::document() const
 {
     ASSERT(m_cueBackgroundBox);
     return m_cueBackgroundBox->document();
 }
 
 void VTTCue::trace(Visitor* visitor)
 {
     visitor->trace(m_vttNodeTree);
     visitor->trace(m_cueBackgroundBox);
     visitor->trace(m_displayTree);
     TextTrackCue::trace(visitor);
 }
 
 } // namespace blink