WebVTT: Implement 'best position' from the rendering section

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 33 matching lines @@
     RenderBlockFlow::trace(visitor);
 }
 
 class SnapToLinesLayouter {
     STACK_ALLOCATED();
 public:
     SnapToLinesLayouter(RenderVTTCue& cueBox, VTTCue::WritingDirection writingDirection, float linePosition)
         : m_cueBox(cueBox)
         , m_cueWritingDirection(writingDirection)
         , m_linePosition(linePosition)
+        , m_bestPositionScore(std::numeric_limits<float>::infinity())
     {
     }
 
     void layout();
 
 private:
     bool isOutside() const;
     bool isOverlapping() const;
+    float computePositionScore() const;
     bool shouldSwitchDirection(InlineFlowBox*, LayoutUnit) const;
 
     void moveBoxesByStep(LayoutUnit);
     bool switchDirection(bool&, LayoutUnit&);
 
     bool findFirstLineBox(InlineFlowBox*&);
     bool initializeLayoutParameters(InlineFlowBox*, LayoutUnit&, LayoutUnit&);
     void placeBoxInDefaultPosition(LayoutUnit, bool&);
 
-    LayoutPoint m_specifiedPosition;
     RenderVTTCue& m_cueBox;
     VTTCue::WritingDirection m_cueWritingDirection;
     float m_linePosition;
+    LayoutPoint m_specifiedPosition;
+    LayoutPoint m_bestPosition;
+    float m_bestPositionScore;
 };
 
 bool SnapToLinesLayouter::findFirstLineBox(InlineFlowBox*& firstLineBox)
 {
     if (m_cueBox.firstChild()->isRenderInline())
         firstLineBox = toRenderInline(m_cueBox.firstChild())->firstLineBox();
     else
         return false;
 
     return true;
@@ skipping 51 matching lines @@
         m_cueBox.setY(m_cueBox.location().y() + position);
     } else {
         // Vertical: ... right by the distance given by position
         m_cueBox.setX(m_cueBox.location().x() + position);
     }
 
     // 13. Remember the position of all the boxes in boxes as their specified position.
     m_specifiedPosition = m_cueBox.location();
 
     // 14. Let best position be null. It will hold a position for boxes, much like specified position in the previous step.
+    ASSERT(m_bestPosition == LayoutPoint::zero());
+
     // 15. Let best position score be null.
+    // (Setting score to positive infinite that should be guaranteed to be
+    // larger than any overlap - and easily recognizable as 'best position is
+    // null' as well.)
+    ASSERT(std::isinf(m_bestPositionScore));
 
     // 16. Let switched be false.
     switched = false;
 }
 
 bool SnapToLinesLayouter::isOutside() const
 {
     return !m_cueBox.containingBlock()->absoluteBoundingBoxRect().contains(m_cueBox.absoluteContentBox());
 }
 
@@ skipping 49 matching lines @@
     // result in a leftwards movement of the boxes in absolute terms.)
     else
         m_cueBox.setX(m_cueBox.location().x() + step);
 }
 
 bool SnapToLinesLayouter::switchDirection(bool& switched, LayoutUnit& step)
 {
     // 24. Switch direction: If switched is true, then move all the boxes in
     // boxes back to their best position, and jump to the step labeled done
     // positioning below.
+    if (switched) {
+        m_cueBox.setLocation(m_bestPosition);
+        return false;
+    }
 
     // 25. Otherwise, move all the boxes in boxes back to their specified
     // position as determined in the earlier step.
     m_cueBox.setLocation(m_specifiedPosition);
 
-    // XX. If switched is true, jump to the step labeled done
-    // positioning below.
-    if (switched)
-        return false;
-
     // 26. Negate step.
     step = -step;
 
     // 27. Set switched to true.
     switched = true;
     return true;
 }
 
+static LayoutUnit computeArea(const LayoutRect& rect)
+{
+    return rect.size().width() * rect.size().height();
+}
+
+float SnapToLinesLayouter::computePositionScore() const
+{
+    // Compute the percentage of the area of the bounding box of the boxes in
+    // boxes that is outside the title area box.
+    LayoutRect boundingBox = m_cueBox.absoluteBoundingBoxRect();
+    LayoutRect titleAreaBox = m_cueBox.containingBlock()->absoluteBoundingBoxRect();
+    LayoutRect boxOverlap = intersection(titleAreaBox, boundingBox);
+    // We know the intersection/overlap, which means we can determine the
+    // non-overlapping part by subtracting that area from the bounding box area.
+    LayoutUnit overlappingArea = computeArea(boxOverlap);
+    LayoutUnit boundingBoxArea = computeArea(boundingBox);
+    ASSERT(overlappingArea >= 0 && overlappingArea <= boundingBoxArea);
+    return (boundingBoxArea - overlappingArea) / boundingBoxArea.toFloat();
+}
+
 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;
     if (!findFirstLineBox(firstLineBox))
         return;
 
     // Step 1 skipped.
 
     LayoutUnit step;
     LayoutUnit position;
     if (!initializeLayoutParameters(firstLineBox, step, position))
         return;
 
     bool switched;
     placeBoxInDefaultPosition(position, switched);
 
     // Step 17 skipped. (margin == 0; title area == video area)
 
     // 18. Step loop: If none of the boxes in boxes would overlap any of the
     // boxes in output, and all of the boxes in output are entirely within the
     // title area box, then jump to the step labeled done positioning below.
     while (isOutside() || isOverlapping()) {
         // 19. Let current position score be the percentage of the area of the
         // bounding box of the boxes in boxes that is outside the title area
         // box.
+        float currentPositionScore = computePositionScore();
+
         // 20. If best position is null (i.e. this is the first run through
         // this loop, switched is still false, the boxes in boxes are at their
         // specified position, and best position score is still null), or if
         // current position score is a lower percentage than that in best
         // position score, then remember the position of all the boxes in boxes
         // as their best position, and set best position score to current
         // position score.
+        if (currentPositionScore < m_bestPositionScore) {
+            m_bestPosition = m_cueBox.location();
+            m_bestPositionScore = currentPositionScore;
+        }
+
         if (!shouldSwitchDirection(firstLineBox, step)) {
             // 22. Move all the boxes in boxes ...
             moveBoxesByStep(step);
             // 23. Jump back to the step labeled step loop.
         } else if (!switchDirection(switched, step)) {
             break;
         }
 
         // 28. Jump back to the step labeled step loop.
     }
@@ skipping 85 matching lines @@
         SnapToLinesLayouter(*this, m_cue->getWritingDirection(), m_cue->calculateComputedLinePosition()).layout();
 
         adjustForTopAndBottomMarginBorderAndPadding();
     } else {
         repositionCueSnapToLinesNotSet();
     }
 }
 
 } // namespace blink