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 201 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);

[leviw_travelin_and_unemployed, 2014/01/09 00:49:54]

Boolean params make me sad. It'd be great if we could use an Enum instead.

 
     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