BidiResolver should not append an isolated run if it is in a other line.

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 204 matching lines @@
     void createBidiRunsForLine(const Iterator& end, VisualDirectionOverride = NoVisualOverride, bool hardLineBreak = false);
 
     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 isEndOfParagraph(const Iterator& end) { return m_current == end || m_current.atEnd(); }
+    bool isEndOfLine(const Iterator& end) { return m_current == end || m_current.atEnd(); }
 
     TextDirection determineParagraphDirectionality(bool* hasStrongDirectionality = 0);
 
     void setMidpointStateForIsolatedRun(Run*, const MidpointState<Iterator>&);
     MidpointState<Iterator> midpointStateForIsolatedRun(Run*);
 
 protected:
     void increment() { m_current.increment(); }
     // FIXME: Instead of InlineBidiResolvers subclassing this method, we should
     // pass in some sort of Traits object which knows how to create runs for appending.
     void appendRun();
 
     Iterator m_current;
     // sor and eor are "start of run" and "end of run" respectively and correpond
     // to abreviations used in UBA spec: http://unicode.org/reports/tr9/#BD7
     Iterator m_sor; // Points to the first character in the current run.
     Iterator m_eor; // Points to the last character in the current run.
     Iterator m_last;
     BidiStatus m_status;
     WTF::Unicode::Direction m_direction;
-    Iterator endOfLine;
+    Iterator m_runAtEndOfLine;
+    Iterator m_endOfLine;
     bool m_reachedEndOfLine;
     Iterator m_lastBeforeET; // Before a EuropeanNumberTerminator
     bool m_emptyRun;
 
     // FIXME: This should not belong to the resolver, but rather be passed
     // into createBidiRunsForLine by the caller.
     BidiRunList<Run> m_runs;
 
     MidpointState<Iterator> m_midpointState;
 
@@ skipping 21 matching lines @@
 }
 #endif
 
 template <class Iterator, class Run>
 void BidiResolver<Iterator, Run>::appendRun()
 {
     if (!m_emptyRun && !m_eor.atEnd()) {
         unsigned startOffset = m_sor.offset();
         unsigned endOffset = m_eor.offset();
 
-        if (!endOfLine.atEnd() && endOffset >= endOfLine.offset()) {
+        if (!m_runAtEndOfLine.atEnd() && endOffset >= m_runAtEndOfLine.offset()) {
             m_reachedEndOfLine = true;
-            endOffset = endOfLine.offset();
+            endOffset = m_runAtEndOfLine.offset();
         }
 
         if (endOffset >= startOffset)
             m_runs.addRun(new Run(startOffset, endOffset + 1, context(), m_direction));
 
         m_eor.increment();
         m_sor = m_eor;
     }
 
     m_direction = WTF::Unicode::OtherNeutral;
@@ skipping 279 matching lines @@
         appendRun();
         m_runs.setLogicallyLastRun(m_runs.lastRun());
         if (override == VisualRightToLeftOverride && m_runs.runCount())
             m_runs.reverseRuns(0, m_runs.runCount() - 1);
         return;
     }
 
     m_emptyRun = true;
 
     m_eor = Iterator();
+    m_endOfLine = end;
 
     m_last = m_current;
-    bool lastParagraphEnded = false;
+    bool lastLineEnded = false;
     BidiResolver<Iterator, Run> stateAtEnd;
 
     while (true) {
         if (inIsolate() && m_emptyRun) {
             m_sor = m_current;
             m_emptyRun = false;
         }
 
-        if (!lastParagraphEnded && isEndOfParagraph(end)) {
+        if (!lastLineEnded && isEndOfLine(end)) {
             if (m_emptyRun)
                 break;
 
             stateAtEnd.m_status = m_status;
             stateAtEnd.m_sor = m_sor;
             stateAtEnd.m_eor = m_eor;
             stateAtEnd.m_last = m_last;
             stateAtEnd.m_reachedEndOfLine = m_reachedEndOfLine;
             stateAtEnd.m_lastBeforeET = m_lastBeforeET;
             stateAtEnd.m_emptyRun = m_emptyRun;
-            endOfLine = m_last;
-            lastParagraphEnded = true;
+            m_runAtEndOfLine = m_last;
+            lastLineEnded = true;
         }
         Direction dirCurrent;
-        if (lastParagraphEnded && (hardLineBreak || m_current.atEnd())) {
+        if (lastLineEnded && (hardLineBreak || m_current.atEnd())) {
             BidiContext* c = context();
             if (hardLineBreak) {
                 // A deviation from the Unicode Bidi Algorithm in order to match
                 // WinIE and user expectations: hard line breaks reset bidi state
                 // coming from unicode bidi control characters, but not those from
                 // DOM nodes with specified directionality
                 stateAtEnd.setContext(c->copyStackRemovingUnicodeEmbeddingContexts());
 
                 dirCurrent = stateAtEnd.context()->dir();
                 stateAtEnd.setEorDir(dirCurrent);
@@ skipping 268 matching lines @@
             // ### implement rule L1
             break;
         case WhiteSpaceNeutral:
             break;
         case OtherNeutral:
             break;
         default:
             break;
         }
 
-        if (lastParagraphEnded && m_eor == m_current) {
+        if (lastLineEnded && m_eor == m_current) {
             if (!m_reachedEndOfLine) {
-                m_eor = endOfLine;
+                m_eor = m_runAtEndOfLine;
                 switch (m_status.eor) {
                 case LeftToRight:
                 case RightToLeft:
                 case ArabicNumber:
                     m_direction = m_status.eor;
                     break;
                 case EuropeanNumber:
                     m_direction = m_status.lastStrong == LeftToRight ? LeftToRight : EuropeanNumber;
                     break;
                 default:
@@ skipping 17 matching lines @@
         m_last = m_current;
 
         if (m_emptyRun) {
             m_sor = m_current;
             m_emptyRun = false;
         }
 
         increment();
         if (!m_currentExplicitEmbeddingSequence.isEmpty()) {
             bool committed = commitExplicitEmbedding();
-            if (committed && lastParagraphEnded) {
+            if (committed && lastLineEnded) {
                 m_current = end;
                 m_status = stateAtEnd.m_status;
                 m_sor = stateAtEnd.m_sor;
                 m_eor = stateAtEnd.m_eor;
                 m_last = stateAtEnd.m_last;
                 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();
-    endOfLine = Iterator();
+    m_runAtEndOfLine = Iterator();

[leviw_travelin_and_unemployed, 2013/10/30 17:44:37]

This naming confuses me. A run is denoted by 2 iterators: one for the start and
one for the end. This is an Iterator type, and since it's just one, it can't be
a run.

+    m_endOfLine = Iterator();
 }
 
 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