VTTCue: Convert uses of std::pair<float, float> to FloatPoint

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 136 matching lines @@
 
     //  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());
 
     // the 'writing-mode' property must be set to writing-mode
     setInlineStyleProperty(CSSPropertyWebkitWritingMode, m_cue->getCSSWritingMode());
 
-    std::pair<float, float> position = m_cue->getCSSPosition();
+    FloatPoint position = m_cue->getCSSPosition();
 
     // the 'top' property must be set to top,
-    setInlineStyleProperty(CSSPropertyTop, position.second, CSSPrimitiveValue::CSS_PERCENTAGE);
+    setInlineStyleProperty(CSSPropertyTop, position.y(), CSSPrimitiveValue::CSS_PERCENTAGE);
 
     // the 'left' property must be set to left
-    setInlineStyleProperty(CSSPropertyLeft, position.first, CSSPrimitiveValue::CSS_PERCENTAGE);
+    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(CSSPropertyHeight, CSSValueAuto);
     } else {
         setInlineStyleProperty(CSSPropertyWidth, CSSValueAuto);
         setInlineStyleProperty(CSSPropertyHeight, static_cast<double>(m_cue->getCSSSize()),  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());
 
     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
         // maintaining the relative positions of the boxes in boxes to each
         // other.
         setInlineStyleProperty(CSSPropertyWebkitTransform,
-            String::format("translate(-%.2f%%, -%.2f%%)", position.first, position.second));
+            String::format("translate(-%.2f%%, -%.2f%%)", position.x(), position.y()));
 
         setInlineStyleProperty(CSSPropertyWhiteSpace, CSSValuePre);
     }
 }
 
 RenderObject* VTTCueBox::createRenderer(RenderStyle*)
 {
     return new RenderVTTCue(this);
 }
 
@@ skipping 411 matching lines @@
     // 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;
 
         switch (resolveCueAlignment(m_cueAlignment, m_displayDirection)) {
         case Left:
-            m_displayPosition.first = visualTextPosition;
+            m_displayPosition.setX(visualTextPosition);
             break;
         case Right:
-            m_displayPosition.first = visualTextPosition - m_displaySize;
+            m_displayPosition.setX(visualTextPosition - m_displaySize);
             break;
         case Middle:
-            m_displayPosition.first = visualTextPosition - m_displaySize / 2;
+            m_displayPosition.setX(visualTextPosition - m_displaySize / 2);
             break;
         default:
             ASSERT_NOT_REACHED();
         }
     } else {
         // Cases for m_writingDirection being VerticalGrowing{Left|Right}
         switch (m_cueAlignment) {
         case Start:
         case Left:
-            m_displayPosition.second = m_textPosition;
+            m_displayPosition.setY(m_textPosition);
             break;
         case End:
         case Right:
-            m_displayPosition.second = m_textPosition - m_displaySize;
+            m_displayPosition.setY(m_textPosition - m_displaySize);
             break;
         case Middle:
-            m_displayPosition.second = m_textPosition - m_displaySize / 2;
+            m_displayPosition.setY(m_textPosition - m_displaySize / 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();
 
     // 10.9 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 && m_writingDirection == Horizontal)
-        m_displayPosition.second = 0;
+        m_displayPosition.setY(0);
 
     if (!m_snapToLines && m_writingDirection == Horizontal)
-        m_displayPosition.second = m_computedLinePosition;
+        m_displayPosition.setY(m_computedLinePosition);
 
     if (m_snapToLines && (m_writingDirection == VerticalGrowingLeft || m_writingDirection == VerticalGrowingRight))
-        m_displayPosition.first = 0;
+        m_displayPosition.setX(0);
 
     if (!m_snapToLines && (m_writingDirection == VerticalGrowingLeft || m_writingDirection == VerticalGrowingRight))
-        m_displayPosition.first = m_computedLinePosition;
+        m_displayPosition.setX(m_computedLinePosition);
 }
 
 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 132 matching lines @@
         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);
     }
 }
 
-std::pair<double, double> VTTCue::getPositionCoordinates() const
+FloatPoint VTTCue::getPositionCoordinates() const
 {
     // This method is used for setting x and y when snap to lines is not set.
-    std::pair<double, double> coordinates;
 
-    if (m_writingDirection == Horizontal && m_displayDirection == CSSValueLtr) {
-        coordinates.first = m_textPosition;
-        coordinates.second = m_computedLinePosition;
+    if (m_writingDirection == Horizontal && m_displayDirection == CSSValueLtr)
+        return FloatPoint(m_textPosition, m_computedLinePosition);
 
-        return coordinates;
-    }
+    if (m_writingDirection == Horizontal && m_displayDirection == CSSValueRtl)
+        return FloatPoint(100 - m_textPosition, m_computedLinePosition);
 
-    if (m_writingDirection == Horizontal && m_displayDirection == CSSValueRtl) {
-        coordinates.first = 100 - m_textPosition;
-        coordinates.second = m_computedLinePosition;
+    if (m_writingDirection == VerticalGrowingLeft)
+        return FloatPoint(100 - m_computedLinePosition, m_textPosition);
 
-        return coordinates;
-    }
-
-    if (m_writingDirection == VerticalGrowingLeft) {
-        coordinates.first = 100 - m_computedLinePosition;
-        coordinates.second = m_textPosition;
-
-        return coordinates;
-    }
-
-    if (m_writingDirection == VerticalGrowingRight) {
-        coordinates.first = m_computedLinePosition;
-        coordinates.second = m_textPosition;
-
-        return coordinates;
-    }
+    if (m_writingDirection == VerticalGrowingRight)
+        return FloatPoint(m_computedLinePosition, m_textPosition);
 
     ASSERT_NOT_REACHED();
-
-    return coordinates;
+    return FloatPoint();
 }
 
 VTTCue::CueSetting VTTCue::settingName(VTTScanner& input)
 {
     CueSetting parsedSetting = None;
     if (input.scan("vertical"))
         parsedSetting = Vertical;
     else if (input.scan("line"))
         parsedSetting = Line;
     else if (input.scan("position"))
@@ skipping 199 matching lines @@
 {
     return displayWritingModeMap[m_writingDirection];
 }
 
 int VTTCue::getCSSSize() const
 {
     ASSERT(m_displaySize != undefinedSize);
     return m_displaySize;
 }
 
-std::pair<double, double> VTTCue::getCSSPosition() const
+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