Changed TextDirection to an enum class and renamed its members

third_party/WebKit/Source/platform/fonts/shaping/ShapeResultBuffer.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/fonts/shaping/ShapeResultBuffer.h"
 
 #include "platform/fonts/CharacterRange.h"
 #include "platform/fonts/GlyphBuffer.h"
 #include "platform/fonts/SimpleFontData.h"
 #include "platform/fonts/shaping/ShapeResultInlineHeaders.h"
@@ skipping 72 matching lines @@
                                                unsigned to,
                                                unsigned runOffset) {
   if (!run)
     return 0;
   float advanceSoFar = initialAdvance;
   const unsigned numGlyphs = run->m_glyphData.size();
   for (unsigned i = 0; i < numGlyphs; ++i) {
     const HarfBuzzRunGlyphData& glyphData = run->m_glyphData[i];
     uint16_t currentCharacterIndex =
         run->m_startIndex + glyphData.characterIndex + runOffset;
-    if ((direction == RTL && currentCharacterIndex >= to) ||
-        (direction == LTR && currentCharacterIndex < from)) {
+    if ((direction == TextDirection::Rtl && currentCharacterIndex >= to) ||
+        (direction == TextDirection::Ltr && currentCharacterIndex < from)) {
       advanceSoFar += glyphData.advance;
-    } else if ((direction == RTL && currentCharacterIndex >= from) ||
-               (direction == LTR && currentCharacterIndex < to)) {
+    } else if ((direction == TextDirection::Rtl &&
+                currentCharacterIndex >= from) ||
+               (direction == TextDirection::Ltr &&
+                currentCharacterIndex < to)) {
       addGlyphToBuffer(glyphBuffer, advanceSoFar, run->m_direction,
                        run->m_fontData.get(), glyphData);
       advanceSoFar += glyphData.advance;
     }
   }
   return advanceSoFar - initialAdvance;
 }
 
 float ShapeResultBuffer::fillGlyphBufferForTextEmphasisRun(
     GlyphBuffer* glyphBuffer,
@@ skipping 16 matching lines @@
   TextDirection direction = textRun.direction();
 
   // A "cluster" in this context means a cluster as it is used by HarfBuzz:
   // The minimal group of characters and corresponding glyphs, that cannot be
   // broken down further from a text shaping point of view.  A cluster can
   // contain multiple glyphs and grapheme clusters, with mutually overlapping
   // boundaries. Below we count grapheme clusters per HarfBuzz clusters, then
   // linearly split the sum of corresponding glyph advances by the number of
   // grapheme clusters in order to find positions for emphasis mark drawing.
   uint16_t clusterStart = static_cast<uint16_t>(
-      direction == RTL ? run->m_startIndex + run->m_numCharacters + runOffset
-                       : run->glyphToCharacterIndex(0) + runOffset);
+      direction == TextDirection::Rtl
+          ? run->m_startIndex + run->m_numCharacters + runOffset
+          : run->glyphToCharacterIndex(0) + runOffset);
 
   float advanceSoFar = initialAdvance;
   const unsigned numGlyphs = run->m_glyphData.size();
   for (unsigned i = 0; i < numGlyphs; ++i) {
     const HarfBuzzRunGlyphData& glyphData = run->m_glyphData[i];
     uint16_t currentCharacterIndex =
         run->m_startIndex + glyphData.characterIndex + runOffset;
     bool isRunEnd = (i + 1 == numGlyphs);
     bool isClusterEnd =
         isRunEnd || (run->glyphToCharacterIndex(i + 1) + runOffset !=
                      currentCharacterIndex);
 
-    if ((direction == RTL && currentCharacterIndex >= to) ||
-        (direction != RTL && currentCharacterIndex < from)) {
+    if ((direction == TextDirection::Rtl && currentCharacterIndex >= to) ||
+        (direction != TextDirection::Rtl && currentCharacterIndex < from)) {
       advanceSoFar += glyphData.advance;
-      direction == RTL ? --clusterStart : ++clusterStart;
+      direction == TextDirection::Rtl ? --clusterStart : ++clusterStart;
       continue;
     }
 
     clusterAdvance += glyphData.advance;
 
     if (textRun.is8Bit()) {
       float glyphAdvanceX = glyphData.advance;
       if (Character::canReceiveTextEmphasis(textRun[currentCharacterIndex])) {
         addEmphasisMark(glyphBuffer, emphasisData, glyphCenter,
                         advanceSoFar + glyphAdvanceX / 2);
       }
       advanceSoFar += glyphAdvanceX;
     } else if (isClusterEnd) {
       uint16_t clusterEnd;
-      if (direction == RTL)
+      if (direction == TextDirection::Rtl)
         clusterEnd = currentCharacterIndex;
       else
         clusterEnd = static_cast<uint16_t>(
             isRunEnd ? run->m_startIndex + run->m_numCharacters + runOffset
                      : run->glyphToCharacterIndex(i + 1) + runOffset);
 
       graphemesInCluster = countGraphemesInCluster(textRun.characters16(),
                                                    textRun.charactersLength(),
                                                    clusterStart, clusterEnd);
       if (!graphemesInCluster || !clusterAdvance)
@@ skipping 56 matching lines @@
     return fillFastHorizontalGlyphBuffer(glyphBuffer, textRun.direction());
 
   float advance = 0;
 
   if (textRun.rtl()) {
     unsigned wordOffset = textRun.length();
     for (unsigned j = 0; j < m_results.size(); j++) {
       unsigned resolvedIndex = m_results.size() - 1 - j;
       const RefPtr<const ShapeResult>& wordResult = m_results[resolvedIndex];
       for (unsigned i = 0; i < wordResult->m_runs.size(); i++) {
-        advance += fillGlyphBufferForRun<RTL>(
+        advance += fillGlyphBufferForRun<TextDirection::Rtl>(
             glyphBuffer, wordResult->m_runs[i].get(), advance, from, to,
             wordOffset - wordResult->numCharacters());
       }
       wordOffset -= wordResult->numCharacters();
     }
   } else {
     unsigned wordOffset = 0;
     for (unsigned j = 0; j < m_results.size(); j++) {
       const RefPtr<const ShapeResult>& wordResult = m_results[j];
       for (unsigned i = 0; i < wordResult->m_runs.size(); i++) {
-        advance +=
-            fillGlyphBufferForRun<LTR>(glyphBuffer, wordResult->m_runs[i].get(),
-                                       advance, from, to, wordOffset);
+        advance += fillGlyphBufferForRun<TextDirection::Ltr>(
+            glyphBuffer, wordResult->m_runs[i].get(), advance, from, to,
+            wordOffset);
       }
       wordOffset += wordResult->numCharacters();
     }
   }
 
   return advance;
 }
 
 float ShapeResultBuffer::fillGlyphBufferForTextEmphasis(
     GlyphBuffer* glyphBuffer,
@@ skipping 23 matching lines @@
 CharacterRange ShapeResultBuffer::getCharacterRange(TextDirection direction,
                                                     float totalWidth,
                                                     unsigned absoluteFrom,
                                                     unsigned absoluteTo) const {
   float currentX = 0;
   float fromX = 0;
   float toX = 0;
   bool foundFromX = false;
   bool foundToX = false;
 
-  if (direction == RTL)
+  if (direction == TextDirection::Rtl)
     currentX = totalWidth;
 
   // The absoluteFrom and absoluteTo arguments represent the start/end offset
   // for the entire run, from/to are continuously updated to be relative to
   // the current word (ShapeResult instance).
   int from = absoluteFrom;
   int to = absoluteTo;
 
   unsigned totalNumCharacters = 0;
   for (unsigned j = 0; j < m_results.size(); j++) {
     const RefPtr<const ShapeResult> result = m_results[j];
-    if (direction == RTL) {
+    if (direction == TextDirection::Rtl) {
       // Convert logical offsets to visual offsets, because results are in
       // logical order while runs are in visual order.
       if (!foundFromX && from >= 0 &&
           static_cast<unsigned>(from) < result->numCharacters())
         from = result->numCharacters() - from - 1;
       if (!foundToX && to >= 0 &&
           static_cast<unsigned>(to) < result->numCharacters())
         to = result->numCharacters() - to - 1;
       currentX -= result->width();
     }
     for (unsigned i = 0; i < result->m_runs.size(); i++) {
       if (!result->m_runs[i])
         continue;
-      ASSERT((direction == RTL) == result->m_runs[i]->rtl());
+      DCHECK_EQ(direction == TextDirection::Rtl, result->m_runs[i]->rtl());
       int numCharacters = result->m_runs[i]->m_numCharacters;
       if (!foundFromX && from >= 0 && from < numCharacters) {
         fromX =
             result->m_runs[i]->xPositionForVisualOffset(from, AdjustToStart) +
             currentX;
         foundFromX = true;
       } else {
         from -= numCharacters;
       }
 
       if (!foundToX && to >= 0 && to < numCharacters) {
         toX = result->m_runs[i]->xPositionForVisualOffset(to, AdjustToEnd) +
               currentX;
         foundToX = true;
       } else {
         to -= numCharacters;
       }
 
       if (foundFromX && foundToX)
         break;
       currentX += result->m_runs[i]->m_width;
     }
-    if (direction == RTL)
+    if (direction == TextDirection::Rtl)
       currentX -= result->width();
     totalNumCharacters += result->numCharacters();
   }
 
   // The position in question might be just after the text.
   if (!foundFromX && absoluteFrom == totalNumCharacters) {
-    fromX = direction == RTL ? 0 : totalWidth;
+    fromX = direction == TextDirection::Rtl ? 0 : totalWidth;
     foundFromX = true;
   }
   if (!foundToX && absoluteTo == totalNumCharacters) {
-    toX = direction == RTL ? 0 : totalWidth;
+    toX = direction == TextDirection::Rtl ? 0 : totalWidth;
     foundToX = true;
   }
   if (!foundFromX)
     fromX = 0;
   if (!foundToX)
-    toX = direction == RTL ? 0 : totalWidth;
+    toX = direction == TextDirection::Rtl ? 0 : totalWidth;
 
   // None of our runs is part of the selection, possibly invalid arguments.
   if (!foundToX && !foundFromX)
     fromX = toX = 0;
   if (fromX < toX)
     return CharacterRange(fromX, toX);
   return CharacterRange(toX, fromX);
 }
 
 void ShapeResultBuffer::addRunInfoRanges(const ShapeResult::RunInfo& runInfo,
@@ skipping 14 matching lines @@
       ranges.append(CharacterRange(end, start));
     else
       ranges.append(CharacterRange(start, end));
   }
 }
 
 Vector<CharacterRange> ShapeResultBuffer::individualCharacterRanges(
     TextDirection direction,
     float totalWidth) const {
   Vector<CharacterRange> ranges;
-  float currentX = direction == RTL ? totalWidth : 0;
+  float currentX = direction == TextDirection::Rtl ? totalWidth : 0;
   for (const RefPtr<const ShapeResult> result : m_results) {
-    if (direction == RTL)
+    if (direction == TextDirection::Rtl)
       currentX -= result->width();
     unsigned runCount = result->m_runs.size();
     for (unsigned index = 0; index < runCount; index++) {
-      unsigned runIndex = direction == RTL ? runCount - 1 - index : index;
+      unsigned runIndex =
+          direction == TextDirection::Rtl ? runCount - 1 - index : index;
       addRunInfoRanges(*result->m_runs[runIndex], currentX, ranges);
       currentX += result->m_runs[runIndex]->m_width;
     }
-    if (direction == RTL)
+    if (direction == TextDirection::Rtl)
       currentX -= result->width();
   }
   return ranges;
 }
 
 int ShapeResultBuffer::offsetForPosition(const TextRun& run,
                                          float targetX,
                                          bool includePartialGlyphs) const {
   unsigned totalOffset;
   if (run.rtl()) {
@@ skipping 21 matching lines @@
       totalOffset += offsetForWord;
       if (targetX >= 0 && targetX <= wordResult->width())
         return totalOffset;
       targetX -= wordResult->width();
     }
   }
   return totalOffset;
 }
 
 }  // namespace blink