Explicitly set text direction for TextRuns

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 122 matching lines @@
             if (dir == WTF::Unicode::RightToLeft)
                 m_level++;
             else if (dir == WTF::Unicode::ArabicNumber || dir == WTF::Unicode::EuropeanNumber)
                 m_level += 2;
         }
     }
 
     int start() const { return m_start; }
     int stop() const { return m_stop; }
     unsigned char level() const { return m_level; }
-    bool reversed(bool visuallyOrdered) { return m_level % 2 && !visuallyOrdered; }
+    bool reversed(bool visuallyOrdered) const { return m_level % 2 && !visuallyOrdered; }
     bool dirOverride(bool visuallyOrdered) { return m_override || visuallyOrdered; }
+    TextDirection direction() const { return reversed(false) ? RTL : LTR; }
 
     BidiCharacterRun* next() const { return m_next; }
     void setNext(BidiCharacterRun* next) { m_next = next; }
 
     // Do not add anything apart from bitfields until after m_next. See https://bugs.webkit.org/show_bug.cgi?id=100173
     bool m_override : 1;
     bool m_hasHyphen : 1; // Used by BidiRun subclass which is a layering violation but enables us to save 8 bytes per object on 64-bit.
     bool m_startsSegment : 1; // Same comment as m_hasHyphen.
     unsigned char m_level;
     BidiCharacterRun* m_next;
@@ skipping 57 matching lines @@
     // 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); m_nestedIsolateCount--; }
     bool inIsolate() const { return m_nestedIsolateCount; }
 
     void embed(WTF::Unicode::Direction, BidiEmbeddingSource);
     bool commitExplicitEmbedding();
 
-    void createBidiRunsForLine(const Iterator& end, VisualDirectionOverride = NoVisualOverride, bool hardLineBreak = false);
+    void createBidiRunsForLine(const Iterator& end, VisualDirectionOverride = NoVisualOverride, bool hardLineBreak = false, bool reorderRuns = true);
 
     BidiRunList<Run>& runs() { return m_runs; }
 
     // FIXME: This used to be part of deleteRuns() but was a layering violation.
     // It's unclear if this is still needed.
     void markCurrentRunEmpty() { m_emptyRun = true; }
 
     Vector<Run*>& isolatedRuns() { return m_isolatedRuns; }
 
     bool isEndOfLine(const Iterator& end) { return m_current == end || m_current.atEnd(); }
@@ skipping 395 matching lines @@
             return RTL;
         }
         increment();
     }
     if (hasStrongDirectionality)
         *hasStrongDirectionality = false;
     return LTR;
 }
 
 template <class Iterator, class Run>
-void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& end, VisualDirectionOverride override, bool hardLineBreak)
+void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& end, VisualDirectionOverride override, bool hardLineBreak, bool reorderRuns)
 {
     using namespace WTF::Unicode;
 
     ASSERT(m_direction == OtherNeutral);
     m_trailingSpaceRun = 0;
 
     m_endOfLine = end;
 
     if (override != NoVisualOverride) {
         m_emptyRun = false;
@@ skipping 378 matching lines @@
                 m_reachedEndOfLine = stateAtEnd.m_reachedEndOfLine;
                 m_lastBeforeET = stateAtEnd.m_lastBeforeET;
                 m_emptyRun = stateAtEnd.m_emptyRun;
                 m_direction = OtherNeutral;
                 break;
             }
         }
     }
 
     m_runs.setLogicallyLastRun(m_runs.lastRun());
-    reorderRunsFromLevels();
+    if (reorderRuns)
+        reorderRunsFromLevels();
     m_endOfRunAtEndOfLine = Iterator();
     m_endOfLine = Iterator();
 
     if (!hardLineBreak && m_runs.runCount())
         applyL1Rule();
 }
 
 template <class Iterator, class Run>
 void BidiResolver<Iterator, Run>::setMidpointStateForIsolatedRun(Run* run, const MidpointState<Iterator>& midpoint)
 {
     ASSERT(!m_midpointStateForIsolatedRun.contains(run));
     m_midpointStateForIsolatedRun.add(run, midpoint);
 }
 
 template<class Iterator, class Run>
 MidpointState<Iterator> BidiResolver<Iterator, Run>::midpointStateForIsolatedRun(Run* run)
 {
     return m_midpointStateForIsolatedRun.take(run);
 }
 
 
 } // namespace WebCore
 
 #endif // BidiResolver_h