Blink Unicode Bidi implementation does not support L1 rule.

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 154 matching lines @@
 // BidiResolver is WebKit's implementation of the Unicode Bidi Algorithm
 // http://unicode.org/reports/tr9
 template <class Iterator, class Run> class BidiResolver {
     WTF_MAKE_NONCOPYABLE(BidiResolver);
 public:
     BidiResolver()
         : m_direction(WTF::Unicode::OtherNeutral)
         , m_reachedEndOfLine(false)
         , m_emptyRun(true)
         , m_nestedIsolateCount(0)
+        , m_trailingSpaceRun(0)
     {
     }
 
 #ifndef NDEBUG
     ~BidiResolver();
 #endif
 
     const Iterator& position() const { return m_current; }
     Iterator& position() { return m_current; }
     void setPositionIgnoringNestedIsolates(const Iterator& position) { m_current = position; }
@@ skipping 11 matching lines @@
     void setEorDir(WTF::Unicode::Direction eorDir) { m_status.eor = eorDir; }
 
     WTF::Unicode::Direction dir() const { return m_direction; }
     void setDir(WTF::Unicode::Direction 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 ? LTR : RTL;
     }
 
     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); m_nestedIsolateCount--; }
     bool inIsolate() const { return m_nestedIsolateCount; }
@@ skipping 13 matching lines @@
 
     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*);
 
     Iterator endOfLine() const { return m_endOfLine; }
 
+    Run* trailingSpaceRun() const { return m_trailingSpaceRun; }
+
 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();
 
+    Run* addTrailingRun(int, int, Run*, BidiContext*, TextDirection) { return 0; }
     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;
     // m_endOfRunAtEndOfLine is "the position last eor in the end of line"
     Iterator m_endOfRunAtEndOfLine;
     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;
 
     unsigned m_nestedIsolateCount;
     Vector<Run*> m_isolatedRuns;
+    Run* m_trailingSpaceRun;
+    TextDirection m_paragraphDirectionality;
 
 private:
     void raiseExplicitEmbeddingLevel(WTF::Unicode::Direction from, WTF::Unicode::Direction to);
     void lowerExplicitEmbeddingLevel(WTF::Unicode::Direction from);
     void checkDirectionInLowerRaiseEmbeddingLevel();
 
     void updateStatusLastFromCurrentDirection(WTF::Unicode::Direction);
     void reorderRunsFromLevels();
 
+    bool needsToApplyL1Rule() { return false; }
+    int findFirstTrailingSpaceAtRun(Run*) { return 0; }
+    void applyL1Rule();

[leviw_travelin_and_unemployed, 2014/01/06 21:46:18]

Can you add a link to the L1 rule here, as well?

+
     Vector<BidiEmbedding, 8> m_currentExplicitEmbeddingSequence;
     HashMap<Run *, MidpointState<Iterator> > m_midpointStateForIsolatedRun;
 };
 
 #ifndef NDEBUG
 template <class Iterator, class Run>
 BidiResolver<Iterator, Run>::~BidiResolver()
 {
     // The owner of this resolver should have handled the isolated runs.
     ASSERT(m_isolatedRuns.isEmpty());
@@ skipping 123 matching lines @@
 
     appendRun();
     m_emptyRun = true;
 
     setLastDir(to);
     setLastStrongDir(to);
     m_eor = Iterator();
 }
 
 template <class Iterator, class Run>
+void BidiResolver<Iterator, Run>::applyL1Rule()
+{
+    ASSERT(m_runs.runCount());
+    if (!needsToApplyL1Rule())
+        return;
+
+    Run* trailingSpaceRun = m_runs.logicallyLastRun();
+
+    int firstSpace = findFirstTrailingSpaceAtRun(trailingSpaceRun);
+    if (firstSpace == trailingSpaceRun->stop())
+        return;
+
+    bool shouldReorder = trailingSpaceRun != (m_paragraphDirectionality == LTR ? m_runs.lastRun() : m_runs.firstRun());
+    if (firstSpace != trailingSpaceRun->start()) {
+        BidiContext* baseContext = context();
+        while (BidiContext* parent = baseContext->parent())
+            baseContext = parent;
+
+        m_trailingSpaceRun = addTrailingRun(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 == LTR) {
+        m_runs.moveRunToEnd(trailingSpaceRun);
+        trailingSpaceRun->m_level = 0;
+    } else {
+        m_runs.moveRunToBeginning(trailingSpaceRun);
+        trailingSpaceRun->m_level = 1;
+    }
+    m_trailingSpaceRun = trailingSpaceRun;
+}
+
+template <class Iterator, class Run>
 bool BidiResolver<Iterator, Run>::commitExplicitEmbedding()
 {
     // When we're "inIsolate()" we're resolving the parent context which
     // ignores (skips over) the isolated content, including embedding levels.
     // We should never accrue embedding levels while skipping over isolated content.
     ASSERT(!inIsolate() || m_currentExplicitEmbeddingSequence.isEmpty());
 
     using namespace WTF::Unicode;
 
     unsigned char fromLevel = context()->level();
@@ skipping 152 matching lines @@
         *hasStrongDirectionality = false;
     return LTR;
 }
 
 template <class Iterator, class Run>
 void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& end, VisualDirectionOverride override, bool hardLineBreak)
 {
     using namespace WTF::Unicode;
 
     ASSERT(m_direction == OtherNeutral);
+    m_trailingSpaceRun = 0;
 
     m_endOfLine = end;
 
     if (override != NoVisualOverride) {
         m_emptyRun = false;
         m_sor = m_current;
         m_eor = Iterator();
         while (m_current != end && !m_current.atEnd()) {
             m_eor = m_current;
             increment();
@@ skipping 376 matching lines @@
                 m_direction = OtherNeutral;
                 break;
             }
         }
     }
 
     m_runs.setLogicallyLastRun(m_runs.lastRun());
     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