Cleanup TextDirection

This patch:
1. Changes kLtr to be 0. In most CPU architectures, 0 is faster and
   smaller code to set to and to compare with.
   This also matches to the assignments in ICU UBiDiDirection[1].
2. Adds comments.
3. Removes type name from function name since it's not needed when it
   was changed to "enum class", and looks redundant.
4. Prefers LTR/RTL than full spell, since they are common enough
   acronyms used in many specs and is more intuitive than full spell.
   Note the style guide[2] prefers to capitalize acronyms.
5. Adds "IsRtl()" for better readability than "!IsLtr()".

[1] https://cs.chromium.org/chromium/src/third_party/icu/source/common/unicode/ubidi.h?type=cs&q=UBiDiDirection&l=419
[2] https://google.github.io/styleguide/cppguide.html#Function_Names

Review-Url: https://codereview.chromium.org/2925293003
Cr-Commit-Position: refs/heads/master@{#478707}

third_party/WebKit/Source/core/html/track/vtt/VTTCue.cpp

@@ -578,7 +578,7 @@ static CSSValueID DetermineTextDirection(DocumentFragment* vtt_root) {
 
     node = NodeTraversal::Next(*node);
   }
-  return IsLeftToRightDirection(text_direction) ? CSSValueLtr : CSSValueRtl;
+  return IsLtr(text_direction) ? CSSValueLtr : CSSValueRtl;
 }
 
 float VTTCue::CalculateComputedTextPosition() const {

third_party/WebKit/Source/platform/LengthBox.cpp

@@ -83,8 +83,8 @@ const Length& LengthBox::Start(WritingMode writing_mode,
                                const Length& right,
                                const Length& bottom) {
   if (IsHorizontalWritingMode(writing_mode))
-    return IsLeftToRightDirection(direction) ? left : right;
-  return IsLeftToRightDirection(direction) ? top : bottom;
+    return IsLtr(direction) ? left : right;
+  return IsLtr(direction) ? top : bottom;
 }
 
 const Length& LengthBox::End(WritingMode writing_mode,
@@ -94,8 +94,8 @@ const Length& LengthBox::End(WritingMode writing_mode,
                              const Length& right,
                              const Length& bottom) {
   if (IsHorizontalWritingMode(writing_mode))
-    return IsLeftToRightDirection(direction) ? right : left;
-  return IsLeftToRightDirection(direction) ? bottom : top;
+    return IsLtr(direction) ? right : left;
+  return IsLtr(direction) ? bottom : top;
 }
 
 const Length& LengthBox::Over(WritingMode writing_mode,

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

@@ -291,9 +291,8 @@ float ShapeResultBloberizer::FillFastHorizontalGlyphs(
   auto results = result_buffer.results_;
 
   for (unsigned i = 0; i < results.size(); ++i) {
-    const auto& word_result = IsLeftToRightDirection(text_direction)
-                                  ? results[i]
-                                  : results[results.size() - 1 - i];
+    const auto& word_result =
+        IsLtr(text_direction) ? results[i] : results[results.size() - 1 - i];
     advance = FillFastHorizontalGlyphs(word_result.Get(), advance);
   }
 

third_party/WebKit/Source/platform/geometry/LayoutRectOutsets.cpp

@@ -95,15 +95,15 @@ LayoutUnit LayoutRectOutsets::After(WritingMode writing_mode) const {
 LayoutUnit LayoutRectOutsets::Start(WritingMode writing_mode,
                                     TextDirection direction) const {
   if (IsHorizontalWritingMode(writing_mode))
-    return IsLeftToRightDirection(direction) ? left_ : right_;
-  return IsLeftToRightDirection(direction) ? top_ : bottom_;
+    return IsLtr(direction) ? left_ : right_;
+  return IsLtr(direction) ? top_ : bottom_;
 }
 
 LayoutUnit LayoutRectOutsets::end(WritingMode writing_mode,
                                   TextDirection direction) const {
   if (IsHorizontalWritingMode(writing_mode))
-    return IsLeftToRightDirection(direction) ? right_ : left_;
-  return IsLeftToRightDirection(direction) ? bottom_ : top_;
+    return IsLtr(direction) ? right_ : left_;
+  return IsLtr(direction) ? bottom_ : top_;
 }
 
 LayoutUnit LayoutRectOutsets::Over(WritingMode writing_mode) const {
@@ -152,12 +152,12 @@ void LayoutRectOutsets::SetStart(WritingMode writing_mode,
                                  TextDirection direction,
                                  LayoutUnit value) {
   if (IsHorizontalWritingMode(writing_mode)) {
-    if (IsLeftToRightDirection(direction))
+    if (IsLtr(direction))
       left_ = value;
     else
       right_ = value;
   } else {
-    if (IsLeftToRightDirection(direction))
+    if (IsLtr(direction))
       top_ = value;
     else
       bottom_ = value;
@@ -168,12 +168,12 @@ void LayoutRectOutsets::SetEnd(WritingMode writing_mode,
                                TextDirection direction,
                                LayoutUnit value) {
   if (IsHorizontalWritingMode(writing_mode)) {
-    if (IsLeftToRightDirection(direction))
+    if (IsLtr(direction))
       right_ = value;
     else
       left_ = value;
   } else {
-    if (IsLeftToRightDirection(direction))
+    if (IsLtr(direction))
       bottom_ = value;
     else
       top_ = value;

third_party/WebKit/Source/platform/text/TextDirection.h

@@ -26,13 +26,28 @@
 #ifndef TextDirection_h
 #define TextDirection_h
 
+#include <cstdint>
+
 namespace blink {
 
-enum class TextDirection : unsigned { kRtl, kLtr };
+// The direction of text in bidirectional scripts such as Arabic or Hebrew.
+//
+// Used for explicit directions such as in the HTML dir attribute or the CSS
+// 'direction' property.
+// https://html.spec.whatwg.org/multipage/dom.html#the-dir-attribute
+// https://drafts.csswg.org/css-writing-modes/#direction
+//
+// Also used for resolved directions by UAX#9 UNICODE BIDIRECTIONAL ALGORITHM.
+// http://unicode.org/reports/tr9/
+enum class TextDirection : uint8_t { kLtr = 0, kRtl = 1 };
 
-inline bool IsLeftToRightDirection(TextDirection direction) {
+inline bool IsLtr(TextDirection direction) {
   return direction == TextDirection::kLtr;
 }
+
+inline bool IsRtl(TextDirection direction) {
+  return direction != TextDirection::kLtr;
+}
 }
 
 #endif