Use the CSS writing-mode rather than the one from VTTCue

Source/core/rendering/RenderVTTCue.cpp

 /*
  * Copyright (C) 2012 Victor Carbune (victor@rosedu.org)
  *
  * 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 29 matching lines @@
 
 void RenderVTTCue::trace(Visitor* visitor)
 {
     visitor->trace(m_cue);
     RenderBlockFlow::trace(visitor);
 }
 
 class SnapToLinesLayouter {
     STACK_ALLOCATED();
 public:
-    SnapToLinesLayouter(RenderVTTCue& cueBox, VTTCue::WritingDirection writingDirection, float linePosition)
+    SnapToLinesLayouter(RenderVTTCue& cueBox, float linePosition)
         : m_cueBox(cueBox)
-        , m_cueWritingDirection(writingDirection)
         , m_linePosition(linePosition)
     {
     }
 
     void layout();
 
 private:
     bool isOutside() const;
     bool isOverlapping() const;
     LayoutUnit computeInitialPositionAdjustment(LayoutUnit&) const;
     bool shouldSwitchDirection(InlineFlowBox*, LayoutUnit) const;
 
     void moveBoxesBy(LayoutUnit distance)
     {
-        if (m_cueWritingDirection == VTTCue::Horizontal)
-            m_cueBox.setY(m_cueBox.location().y() + distance);
-        else
-            m_cueBox.setX(m_cueBox.location().x() + distance);
+        m_cueBox.setLogicalTop(m_cueBox.logicalTop() + distance);
     }
 
     InlineFlowBox* findFirstLineBox() const;
 
     LayoutPoint m_specifiedPosition;
     RenderVTTCue& m_cueBox;
-    VTTCue::WritingDirection m_cueWritingDirection;
     float m_linePosition;
 };
 
 InlineFlowBox* SnapToLinesLayouter::findFirstLineBox() const
 {
     if (!m_cueBox.firstChild()->isRenderInline())
         return nullptr;
     return toRenderInline(m_cueBox.firstChild())->firstLineBox();
 }
 
 LayoutUnit SnapToLinesLayouter::computeInitialPositionAdjustment(LayoutUnit& step) const
 {
     // 6. Let line position be the text track cue computed line position.
     // 7. Round line position to an integer by adding 0.5 and then flooring it.
     LayoutUnit linePosition = floorf(m_linePosition + 0.5f);
 
+    WritingMode writingMode = m_cueBox.style()->writingMode();
     // 8. Vertical Growing Left: Add one to line position then negate it.
-    if (m_cueWritingDirection == VTTCue::VerticalGrowingLeft)
+    if (writingMode == RightToLeftWritingMode)
         linePosition = -(linePosition + 1);
 
     // 9. Let position be the result of multiplying step and line position.
     LayoutUnit position = step * linePosition;
 
     // 10. Vertical Growing Left: Decrease position by the width of the
     // bounding box of the boxes in boxes, then increase position by step.
-    if (m_cueWritingDirection == VTTCue::VerticalGrowingLeft) {
+    if (writingMode == RightToLeftWritingMode) {
         position -= m_cueBox.size().width();
         position += step;
     }
 
     // 11. If line position is less than zero...
     if (linePosition < 0) {
         RenderBlock* parentBlock = m_cueBox.containingBlock();
 
         // Horizontal / Vertical: ... then increase position by the
         // height / width of the video's rendering area ...
-        position += m_cueWritingDirection == VTTCue::Horizontal ? parentBlock->size().height() : parentBlock->size().width();
+        position += blink::isHorizontalWritingMode(writingMode) ? parentBlock->size().height() : parentBlock->size().width();
 
         // ... and negate step.
         step = -step;
     }
     return position;
 }
 
 bool SnapToLinesLayouter::isOutside() const
 {
     return !m_cueBox.containingBlock()->absoluteBoundingBoxRect().contains(m_cueBox.absoluteContentBox());
 }
 
 bool SnapToLinesLayouter::isOverlapping() const
 {
     for (RenderObject* box = m_cueBox.previousSibling(); box; box = box->previousSibling()) {
         IntRect boxRect = box->absoluteBoundingBoxRect();
 
         if (m_cueBox.absoluteBoundingBoxRect().intersects(boxRect))
             return true;
     }
 
     return false;
 }
 
 bool SnapToLinesLayouter::shouldSwitchDirection(InlineFlowBox* firstLineBox, LayoutUnit step) const
 {
-    LayoutUnit top = m_cueBox.location().y();
-    LayoutUnit left = m_cueBox.location().x();
-    LayoutUnit bottom = top + firstLineBox->size().height();
-    LayoutUnit right = left + firstLineBox->size().width();
-
     // 21. Horizontal: If step is negative and the top of the first line box in
     // boxes is now above the top of the title area, or if step is positive and
     // the bottom of the first line box in boxes is now below the bottom of the
     // title area, jump to the step labeled switch direction.
-    LayoutUnit parentHeight = m_cueBox.containingBlock()->size().height();
-    if (m_cueWritingDirection == VTTCue::Horizontal && ((step < 0 && top < 0) || (step > 0 && bottom > parentHeight)))
-        return true;
-
-    // 21. Vertical: If step is negative and the left edge of the first line
+    // Vertical: If step is negative and the left edge of the first line
     // box in boxes is now to the left of the left edge of the title area, or
     // if step is positive and the right edge of the first line box in boxes is
     // now to the right of the right edge of the title area, jump to the step
     // labeled switch direction.
-    LayoutUnit parentWidth = m_cueBox.containingBlock()->size().width();
-    if (m_cueWritingDirection != VTTCue::Horizontal && ((step < 0 && left < 0) || (step > 0 && right > parentWidth)))
+    LayoutUnit logicalTop = m_cueBox.logicalTop();
+    if (step < 0 && logicalTop < 0)
         return true;
-
+    if (step > 0 && logicalTop + firstLineBox->logicalHeight() > m_cueBox.containingBlock()->logicalHeight())
+        return true;
     return false;
 }
 
 void SnapToLinesLayouter::layout()
 {
     // http://dev.w3.org/html5/webvtt/#dfn-apply-webvtt-cue-settings
     // Step 13, "If cue's text track cue snap-to-lines flag is set".
 
     InlineFlowBox* firstLineBox = findFirstLineBox();
     if (!firstLineBox)
         return;
 
     // Steps 1-3 skipped.
     // 4. Horizontal: Let step be the height of the first line box in boxes.
     //    Vertical: Let step be the width of the first line box in boxes.
-    LayoutUnit step = m_cueWritingDirection == VTTCue::Horizontal ? firstLineBox->size().height() : firstLineBox->size().width();
+    LayoutUnit step = firstLineBox->logicalHeight();
 
     // 5. If step is zero, then jump to the step labeled done positioning below.
     if (!step)
         return;
 
     // Steps 6-11.
     LayoutUnit positionAdjustment = computeInitialPositionAdjustment(step);
 
     // 12. Move all boxes in boxes ...
     // Horizontal: ... down by the distance given by position
@@ skipping 141 matching lines @@
     // have positioning information.
     if (!m_cue->regionId().isEmpty())
         return;
 
     ASSERT(firstChild());
 
     LayoutState state(*this, locationOffset());
 
     // http://dev.w3.org/html5/webvtt/#dfn-apply-webvtt-cue-settings - step 13.
     if (m_cue->snapToLines()) {
-        SnapToLinesLayouter(*this, m_cue->getWritingDirection(), m_cue->calculateComputedLinePosition()).layout();
+        SnapToLinesLayouter(*this, m_cue->calculateComputedLinePosition()).layout();
 
         adjustForTopAndBottomMarginBorderAndPadding();
     } else {
         repositionCueSnapToLinesNotSet();
     }
 }
 
 } // namespace blink