[WebVTT] Rename Middle to Center

third_party/WebKit/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 61 matching lines @@
 static const String& autoKeyword() {
   DEFINE_STATIC_LOCAL(const String, autoString, ("auto"));
   return autoString;
 }
 
 static const String& startKeyword() {
   DEFINE_STATIC_LOCAL(const String, start, ("start"));
   return start;
 }
 
-static const String& middleKeyword() {
-  DEFINE_STATIC_LOCAL(const String, middle, ("middle"));
-  return middle;
+static const String& centerKeyword() {
+  DEFINE_STATIC_LOCAL(const String, center, ("center"));
+  return center;
 }
 
 static const String& endKeyword() {
   DEFINE_STATIC_LOCAL(const String, end, ("end"));
   return end;
 }
 
 static const String& leftKeyword() {
   DEFINE_STATIC_LOCAL(const String, left, ("left"));
   return left;
@@ skipping 137 matching lines @@
 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_textPosition(std::numeric_limits<float>::quiet_NaN()),
       m_cueSize(100),
       m_writingDirection(Horizontal),
-      m_cueAlignment(Middle),
+      m_cueAlignment(Center),
       m_vttNodeTree(nullptr),
       m_cueBackgroundBox(HTMLDivElement::create(document)),
       m_snapToLines(true),
       m_displayTreeShouldChange(true) {
   UseCounter::count(document, UseCounter::VTTCue);
   m_cueBackgroundBox->setShadowPseudoId(cueShadowPseudoId());
 }
 
 VTTCue::~VTTCue() {}
 
@@ skipping 136 matching lines @@
 
   cueWillChange();
   m_cueSize = floatSize;
   cueDidChange();
 }
 
 const String& VTTCue::align() const {
   switch (m_cueAlignment) {
     case Start:
       return startKeyword();
-    case Middle:
-      return middleKeyword();
+    case Center:
+      return centerKeyword();
     case End:
       return endKeyword();
     case Left:
       return leftKeyword();
     case Right:
       return rightKeyword();
     default:
       NOTREACHED();
       return emptyString;
   }
 }
 
 void VTTCue::setAlign(const String& value) {
   CueAlignment alignment = m_cueAlignment;
   if (value == startKeyword())
     alignment = Start;
-  else if (value == middleKeyword())
-    alignment = Middle;
+  else if (value == centerKeyword())
+    alignment = Center;
   else if (value == endKeyword())
     alignment = End;
   else if (value == leftKeyword())
     alignment = Left;
   else if (value == rightKeyword())
     alignment = Right;
   else
     NOTREACHED();
 
   if (alignment == m_cueAlignment)
@@ skipping 163 matching lines @@
     // 2. If the cue text alignment is start or left, return 0 and abort these
     // steps.
     case Start:
     case Left:
       return 0;
     // 3. If the cue text alignment is end or right, return 100 and abort these
     // steps.
     case End:
     case Right:
       return 100;
-    // 4. If the cue text alignment is middle, return 50 and abort these steps.
-    case Middle:
+    // 4. If the cue text alignment is center, return 50 and abort these steps.
+    case Center:
       return 50;
     default:
       NOTREACHED();
       return 0;
   }
 }
 
 VTTCue::CueAlignment VTTCue::calculateComputedCueAlignment() const {
   switch (m_cueAlignment) {
     case VTTCue::Left:
@@ skipping 26 matching lines @@
   // Note: The 'text-align' property is also determined here so that
   // VTTCueBox::applyCSSProperties need not have access to a VTTCue.
   displayParameters.textAlign = displayAlignmentMap[getCueAlignment()];
 
   // 3. If the cue writing direction is horizontal, then let block-flow be
   // 'tb'. Otherwise, if the cue writing direction is vertical growing left,
   // then let block-flow be 'lr'. Otherwise, the cue writing direction is
   // vertical growing right; let block-flow be 'rl'.
   displayParameters.writingMode = displayWritingModeMap[m_writingDirection];
 
-  // Resolve the cue alignment to one of the values {start, end, middle}.
+  // Resolve the cue alignment to one of the values {start, end, center}.
   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) {
+  } else if (computedCueAlignment == Center) {
     maximumSize = computedTextPosition <= 50 ? computedTextPosition
                                              : (100 - computedTextPosition);
     maximumSize = maximumSize * 2;
   } else {
     NOTREACHED();
   }
 
   // 5. If the cue size is less than maximum size, then let size
   // be cue size. Otherwise, let size be maximum size.
   displayParameters.size = std::min(m_cueSize, maximumSize);
 
   // 6. If the 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:
         displayParameters.position.setX(computedTextPosition);
         break;
       case End:
         displayParameters.position.setX(computedTextPosition -
                                         displayParameters.size);
         break;
-      case Middle:
+      case Center:
         displayParameters.position.setX(computedTextPosition -
                                         displayParameters.size / 2);
         break;
       default:
         NOTREACHED();
     }
   } else {
     // Cases for m_writingDirection being VerticalGrowing{Left|Right}
     switch (computedCueAlignment) {
       case Start:
         displayParameters.position.setY(computedTextPosition);
         break;
       case End:
         displayParameters.position.setY(computedTextPosition -
                                         displayParameters.size);
         break;
-      case Middle:
+      case Center:
         displayParameters.position.setY(computedTextPosition -
                                         displayParameters.size / 2);
         break;
       default:
         NOTREACHED();
     }
   }
 
   // A cue has a computed line whose value is defined in terms of
   // the other aspects of the cue.
@@ skipping 132 matching lines @@
 
   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);
+  if (m_cueAlignment != Center)
+    UseCounter::count(document(), UseCounter::VTTCueRenderAlignNotCenter);
 
   VTTCueBox* displayBox = getDisplayTree();
   if (!region()) {
     if (displayBox->hasChildren() && !container.contains(displayBox)) {
       // Note: the display tree of a cue is removed when the active flag of the
       // cue is unset.
       container.appendChild(displayBox);
     }
   } else {
     HTMLDivElement* regionNode = region()->getDisplayTree(document());
@@ skipping 171 matching lines @@
         m_cueSize = number;
         break;
       }
       case Align: {
         // If name is a case-sensitive match for "align"
         // 1. If value is a case-sensitive match for the string "start",
         //    then let cue's WebVTT cue text alignment be start alignment.
         if (input.scanRun(valueRun, startKeyword()))
           m_cueAlignment = Start;
 
-        // 2. If value is a case-sensitive match for the string "middle",
-        //    then let cue's WebVTT cue text alignment be middle alignment.
-        else if (input.scanRun(valueRun, middleKeyword()))
-          m_cueAlignment = Middle;
+        // 2. If value is a case-sensitive match for the string "center",
+        //    then let cue's WebVTT cue text alignment be center alignment.
+        else if (input.scanRun(valueRun, centerKeyword()))
+          m_cueAlignment = Center;
 
         // 3. If value is a case-sensitive match for the string "end", then
         //    let cue's WebVTT cue text alignment be end alignment.
         else if (input.scanRun(valueRun, endKeyword()))
           m_cueAlignment = End;
 
         // 4. If value is a case-sensitive match for the string "left",
         //    then let cue's WebVTT cue text alignment be left alignment.
         else if (input.scanRun(valueRun, leftKeyword()))
           m_cueAlignment = Left;
@@ skipping 51 matching lines @@
 
 DEFINE_TRACE(VTTCue) {
   visitor->trace(m_region);
   visitor->trace(m_vttNodeTree);
   visitor->trace(m_cueBackgroundBox);
   visitor->trace(m_displayTree);
   TextTrackCue::trace(visitor);
 }
 
 }  // namespace blink