Change computed style enums to be prefixed with 'k'.

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

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008 Apple Inc.  All right reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 112 matching lines @@
   DISALLOW_NEW();
   BidiStatus()
       : eor(WTF::Unicode::OtherNeutral),
         lastStrong(WTF::Unicode::OtherNeutral),
         last(WTF::Unicode::OtherNeutral) {}
 
   // Creates a BidiStatus representing a new paragraph root with a default
   // direction.  Uses TextDirection as it only has two possibilities instead of
   // WTF::Unicode::Direction which has 19.
   BidiStatus(TextDirection textDirection, bool isOverride) {
-    WTF::Unicode::CharDirection direction = textDirection == TextDirection::Ltr
+    WTF::Unicode::CharDirection direction = textDirection == TextDirection::kLtr
                                                 ? WTF::Unicode::LeftToRight
                                                 : WTF::Unicode::RightToLeft;
     eor = lastStrong = last = direction;
-    context = BidiContext::create(textDirection == TextDirection::Ltr ? 0 : 1,
+    context = BidiContext::create(textDirection == TextDirection::kLtr ? 0 : 1,
                                   direction, isOverride);
   }
 
   BidiStatus(WTF::Unicode::CharDirection eorDir,
              WTF::Unicode::CharDirection lastStrongDir,
              WTF::Unicode::CharDirection lastDir,
              PassRefPtr<BidiContext> bidiContext)
       : eor(eorDir),
         lastStrong(lastStrongDir),
         last(lastDir),
         context(bidiContext) {}
 
   // Creates a BidiStatus for Isolates (RLI/LRI).
   // The rule X5a ans X5b of UAX#9: http://unicode.org/reports/tr9/#X5a
   static BidiStatus createForIsolate(TextDirection textDirection,
                                      bool isOverride,
                                      unsigned char level) {
     WTF::Unicode::CharDirection direction;
-    if (textDirection == TextDirection::Rtl) {
+    if (textDirection == TextDirection::kRtl) {
       level = nextGreaterOddLevel(level);
       direction = WTF::Unicode::RightToLeft;
     } else {
       level = nextGreaterEvenLevel(level);
       direction = WTF::Unicode::LeftToRight;
     }
     RefPtr<BidiContext> context =
         BidiContext::create(level, direction, isOverride, FromStyleOrDOM);
 
     // This copies BidiStatus and may churn the ref on BidiContext.
@@ skipping 82 matching lines @@
   void setEorDir(WTF::Unicode::CharDirection eorDir) { m_status.eor = eorDir; }
 
   WTF::Unicode::CharDirection dir() const { return m_direction; }
   void setDir(WTF::Unicode::CharDirection d) { m_direction = d; }
 
   const BidiStatus& status() const { return m_status; }
   void setStatus(const BidiStatus s) {
     ASSERT(s.context);
     m_status = s;
     m_paragraphDirectionality = s.context->dir() == WTF::Unicode::LeftToRight
-                                    ? TextDirection::Ltr
-                                    : TextDirection::Rtl;
+                                    ? TextDirection::kLtr
+                                    : TextDirection::kRtl;
   }
 
   MidpointState<Iterator>& midpointState() { return m_midpointState; }
 
   // The current algorithm handles nested isolates one layer of nesting at a
   // time.  But when we layout each isolated span, we will walk into (and
   // ignore) all child isolated spans.
   void enterIsolate() { m_nestedIsolateCount++; }
   void exitIsolate() {
     ASSERT(m_nestedIsolateCount >= 1);
@@ skipping 275 matching lines @@
   if (!needsToApplyL1Rule(runs))
     return;
 
   Run* trailingSpaceRun = runs.logicallyLastRun();
 
   int firstSpace = findFirstTrailingSpaceAtRun(trailingSpaceRun);
   if (firstSpace == trailingSpaceRun->stop())
     return;
 
   bool shouldReorder =
-      trailingSpaceRun != (m_paragraphDirectionality == TextDirection::Ltr
+      trailingSpaceRun != (m_paragraphDirectionality == TextDirection::kLtr
                                ? runs.lastRun()
                                : runs.firstRun());
   if (firstSpace != trailingSpaceRun->start()) {
     BidiContext* baseContext = context();
     while (BidiContext* parent = baseContext->parent())
       baseContext = parent;
 
     m_trailingSpaceRun = addTrailingRun(
         runs, firstSpace, trailingSpaceRun->m_stop, trailingSpaceRun,
         baseContext, m_paragraphDirectionality);
     ASSERT(m_trailingSpaceRun);
     trailingSpaceRun->m_stop = firstSpace;
     return;
   }
   if (!shouldReorder) {
     m_trailingSpaceRun = trailingSpaceRun;
     return;
   }
 
-  if (m_paragraphDirectionality == TextDirection::Ltr) {
+  if (m_paragraphDirectionality == TextDirection::kLtr) {
     runs.moveRunToEnd(trailingSpaceRun);
     trailingSpaceRun->m_level = 0;
   } else {
     runs.moveRunToBeginning(trailingSpaceRun);
     trailingSpaceRun->m_level = 1;
   }
   m_trailingSpaceRun = trailingSpaceRun;
 }
 
 template <class Iterator, class Run, class IsolatedRun>
@@ skipping 158 matching lines @@
       // and retry.
       if (!U16_IS_TRAIL(low))
         continue;
       current = U16_GET_SUPPLEMENTARY(high, low);
     }
     WTF::Unicode::CharDirection charDirection =
         WTF::Unicode::direction(current);
     if (charDirection == WTF::Unicode::LeftToRight) {
       if (hasStrongDirectionality)
         *hasStrongDirectionality = true;
-      return TextDirection::Ltr;
+      return TextDirection::kLtr;
     }
     if (charDirection == WTF::Unicode::RightToLeft ||
         charDirection == WTF::Unicode::RightToLeftArabic) {
       if (hasStrongDirectionality)
         *hasStrongDirectionality = true;
-      return TextDirection::Rtl;
+      return TextDirection::kRtl;
     }
     increment();
   }
   if (hasStrongDirectionality)
     *hasStrongDirectionality = false;
-  return TextDirection::Ltr;
+  return TextDirection::kLtr;
 }
 
 inline TextDirection directionForCharacter(UChar32 character) {
   WTF::Unicode::CharDirection charDirection =
       WTF::Unicode::direction(character);
   if (charDirection == WTF::Unicode::RightToLeft ||
       charDirection == WTF::Unicode::RightToLeftArabic)
-    return TextDirection::Rtl;
-  return TextDirection::Ltr;
+    return TextDirection::kRtl;
+  return TextDirection::kLtr;
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::createBidiRunsForLine(
     const Iterator& end,
     VisualDirectionOverride override,
     bool hardLineBreak,
     bool reorderRuns) {
   using namespace WTF::Unicode;
 
@@ skipping 429 matching lines @@
 template <class Iterator, class Run, class IsolatedRun>
 MidpointState<Iterator>
 BidiResolver<Iterator, Run, IsolatedRun>::midpointStateForIsolatedRun(
     Run& run) {
   return m_midpointStateForIsolatedRun.take(&run);
 }
 
 }  // namespace blink
 
 #endif  // BidiResolver_h