Add context information to BidiResolver.isolatedRuns()

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 160 matching lines @@
 {
     return !(status1 == status2);
 }
 
 enum VisualDirectionOverride {
     NoVisualOverride,
     VisualLeftToRightOverride,
     VisualRightToLeftOverride
 };
 
+class NoIsolatedRun {
+};
+
 // BidiResolver is WebKit's implementation of the Unicode Bidi Algorithm
 // http://unicode.org/reports/tr9
-template <class Iterator, class Run> class BidiResolver {
+template <class Iterator, class Run, class IsolatedRun = NoIsolatedRun> 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)
     {
     }
@@ skipping 42 matching lines @@
     bool commitExplicitEmbedding(BidiRunList<Run>&);
 
     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; }
+    Vector<IsolatedRun>& isolatedRuns() { return m_isolatedRuns; }
 
     bool isEndOfLine(const Iterator& end) { return m_current == end || m_current.atEnd(); }
 
     TextDirection determineParagraphDirectionality(bool* hasStrongDirectionality = 0)
     {
         bool breakOnParagraph = true;
         return determineDirectionalityInternal(breakOnParagraph, hasStrongDirectionality);
     }
     TextDirection determineDirectionality(bool* hasStrongDirectionality = 0)
     {
         bool breakOnParagraph = false;
         return determineDirectionalityInternal(breakOnParagraph, hasStrongDirectionality);
     }
 
-    void setMidpointStateForIsolatedRun(Run*, const MidpointState<Iterator>&);
-    MidpointState<Iterator> midpointStateForIsolatedRun(Run*);
+    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(BidiRunList<Run>&);
@@ skipping 14 matching lines @@
     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;
+    Vector<IsolatedRun> m_isolatedRuns;
     Run* m_trailingSpaceRun;
     TextDirection m_paragraphDirectionality;
 
 private:
     void raiseExplicitEmbeddingLevel(BidiRunList<Run>&, WTF::Unicode::Direction from, WTF::Unicode::Direction to);
     void lowerExplicitEmbeddingLevel(BidiRunList<Run>&, WTF::Unicode::Direction from);
     void checkDirectionInLowerRaiseEmbeddingLevel();
 
     void updateStatusLastFromCurrentDirection(WTF::Unicode::Direction);
     void reorderRunsFromLevels(BidiRunList<Run>&) const;
 
     bool needsToApplyL1Rule(BidiRunList<Run>&) { return false; }
     int findFirstTrailingSpaceAtRun(Run*) { return 0; }
     // http://www.unicode.org/reports/tr9/#L1
     void applyL1Rule(BidiRunList<Run>&);
 
     TextDirection determineDirectionalityInternal(bool breakOnParagraph, bool* hasStrongDirectionality);
 
     Vector<BidiEmbedding, 8> m_currentExplicitEmbeddingSequence;
     HashMap<Run *, MidpointState<Iterator>> m_midpointStateForIsolatedRun;
 };
 
 #if ENABLE(ASSERT)
-template <class Iterator, class Run>
-BidiResolver<Iterator, Run>::~BidiResolver()
+template <class Iterator, class Run, class IsolatedRun>
+BidiResolver<Iterator, Run, IsolatedRun>::~BidiResolver()
 {
     // The owner of this resolver should have handled the isolated runs.
     ASSERT(m_isolatedRuns.isEmpty());
 }
 #endif
 
-template <class Iterator, class Run>
-void BidiResolver<Iterator, Run>::appendRun(BidiRunList<Run>& runs)
+template <class Iterator, class Run, class IsolatedRun>
+void BidiResolver<Iterator, Run, IsolatedRun>::appendRun(BidiRunList<Run>& runs)
 {
     if (!m_emptyRun && !m_eor.atEnd()) {
         unsigned startOffset = m_sor.offset();
         unsigned endOffset = m_eor.offset();
 
         if (!m_endOfRunAtEndOfLine.atEnd() && endOffset >= m_endOfRunAtEndOfLine.offset()) {
             m_reachedEndOfLine = true;
             endOffset = m_endOfRunAtEndOfLine.offset();
         }
 
@@ skipping 13 matching lines @@
         }
 
         m_eor.increment();
         m_sor = m_eor;
     }
 
     m_direction = WTF::Unicode::OtherNeutral;
     m_status.eor = WTF::Unicode::OtherNeutral;
 }
 
-template <class Iterator, class Run>
-void BidiResolver<Iterator, Run>::embed(WTF::Unicode::Direction dir, BidiEmbeddingSource source)
+template <class Iterator, class Run, class IsolatedRun>
+void BidiResolver<Iterator, Run, IsolatedRun>::embed(WTF::Unicode::Direction dir, BidiEmbeddingSource source)
 {
     // Isolated spans compute base directionality during their own UBA run.
     // Do not insert fake embed characters once we enter an isolated span.
     ASSERT(!inIsolate());
     using namespace WTF::Unicode;
 
     ASSERT(dir == PopDirectionalFormat || dir == LeftToRightEmbedding || dir == LeftToRightOverride || dir == RightToLeftEmbedding || dir == RightToLeftOverride);
     m_currentExplicitEmbeddingSequence.append(BidiEmbedding(dir, source));
 }
 
-template <class Iterator, class Run>
-void BidiResolver<Iterator, Run>::checkDirectionInLowerRaiseEmbeddingLevel()
+template <class Iterator, class Run, class IsolatedRun>
+void BidiResolver<Iterator, Run, IsolatedRun>::checkDirectionInLowerRaiseEmbeddingLevel()
 {
     using namespace WTF::Unicode;
 
     ASSERT(m_status.eor != OtherNeutral || m_eor.atEnd());
     ASSERT(m_status.last != NonSpacingMark
         && m_status.last != BoundaryNeutral
         && m_status.last != RightToLeftEmbedding
         && m_status.last != LeftToRightEmbedding
         && m_status.last != RightToLeftOverride
         && m_status.last != LeftToRightOverride
         && m_status.last != PopDirectionalFormat);
     if (m_direction == OtherNeutral)
         m_direction = m_status.lastStrong == LeftToRight ? LeftToRight : RightToLeft;
 }
 
-template <class Iterator, class Run>
-void BidiResolver<Iterator, Run>::lowerExplicitEmbeddingLevel(BidiRunList<Run>& runs, WTF::Unicode::Direction from)
+template <class Iterator, class Run, class IsolatedRun>
+void BidiResolver<Iterator, Run, IsolatedRun>::lowerExplicitEmbeddingLevel(BidiRunList<Run>& runs, WTF::Unicode::Direction from)
 {
     using namespace WTF::Unicode;
 
     if (!m_emptyRun && m_eor != m_last) {
         checkDirectionInLowerRaiseEmbeddingLevel();
         // bidi.sor ... bidi.eor ... bidi.last eor; need to append the bidi.sor-bidi.eor run or extend it through bidi.last
         if (from == LeftToRight) {
             // bidi.sor ... bidi.eor ... bidi.last L
             if (m_status.eor == EuropeanNumber) {
                 if (m_status.lastStrong != LeftToRight) {
@@ skipping 16 matching lines @@
 
     appendRun(runs);
     m_emptyRun = true;
 
     // sor for the new run is determined by the higher level (rule X10)
     setLastDir(from);
     setLastStrongDir(from);
     m_eor = Iterator();
 }
 
-template <class Iterator, class Run>
-void BidiResolver<Iterator, Run>::raiseExplicitEmbeddingLevel(BidiRunList<Run>& runs, WTF::Unicode::Direction from, WTF::Unicode::Direction to)
+template <class Iterator, class Run, class IsolatedRun>
+void BidiResolver<Iterator, Run, IsolatedRun>::raiseExplicitEmbeddingLevel(BidiRunList<Run>& runs, WTF::Unicode::Direction from, WTF::Unicode::Direction to)
 {
     using namespace WTF::Unicode;
 
     if (!m_emptyRun && m_eor != m_last) {
         checkDirectionInLowerRaiseEmbeddingLevel();
         // bidi.sor ... bidi.eor ... bidi.last eor; need to append the bidi.sor-bidi.eor run or extend it through bidi.last
         if (to == LeftToRight) {
             // bidi.sor ... bidi.eor ... bidi.last L
             if (m_status.eor == EuropeanNumber) {
                 if (m_status.lastStrong != LeftToRight) {
@@ skipping 17 matching lines @@
     }
 
     appendRun(runs);
     m_emptyRun = true;
 
     setLastDir(to);
     setLastStrongDir(to);
     m_eor = Iterator();
 }
 
-template <class Iterator, class Run>
-void BidiResolver<Iterator, Run>::applyL1Rule(BidiRunList<Run>& runs)
+template <class Iterator, class Run, class IsolatedRun>
+void BidiResolver<Iterator, Run, IsolatedRun>::applyL1Rule(BidiRunList<Run>& runs)
 {
     ASSERT(runs.runCount());
     if (!needsToApplyL1Rule(runs))
         return;
 
     Run* trailingSpaceRun = runs.logicallyLastRun();
 
     int firstSpace = findFirstTrailingSpaceAtRun(trailingSpaceRun);
     if (firstSpace == trailingSpaceRun->stop())
         return;
@@ skipping 17 matching lines @@
     if (m_paragraphDirectionality == LTR) {
         runs.moveRunToEnd(trailingSpaceRun);
         trailingSpaceRun->m_level = 0;
     } else {
         runs.moveRunToBeginning(trailingSpaceRun);
         trailingSpaceRun->m_level = 1;
     }
     m_trailingSpaceRun = trailingSpaceRun;
 }
 
-template <class Iterator, class Run>
-bool BidiResolver<Iterator, Run>::commitExplicitEmbedding(BidiRunList<Run>& runs)
+template <class Iterator, class Run, class IsolatedRun>
+bool BidiResolver<Iterator, Run, IsolatedRun>::commitExplicitEmbedding(BidiRunList<Run>& runs)
 {
     // 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();
     RefPtr<BidiContext> toContext = context();
@@ skipping 23 matching lines @@
     else if (toLevel < fromLevel)
         lowerExplicitEmbeddingLevel(runs, fromLevel % 2 ? RightToLeft : LeftToRight);
 
     setContext(toContext);
 
     m_currentExplicitEmbeddingSequence.clear();
 
     return fromLevel != toLevel;
 }
 
-template <class Iterator, class Run>
-inline void BidiResolver<Iterator, Run>::updateStatusLastFromCurrentDirection(WTF::Unicode::Direction dirCurrent)
+template <class Iterator, class Run, class IsolatedRun>
+inline void BidiResolver<Iterator, Run, IsolatedRun>::updateStatusLastFromCurrentDirection(WTF::Unicode::Direction dirCurrent)
 {
     using namespace WTF::Unicode;
     switch (dirCurrent) {
     case EuropeanNumberTerminator:
         if (m_status.last != EuropeanNumber)
             m_status.last = EuropeanNumberTerminator;
         break;
     case EuropeanNumberSeparator:
     case CommonNumberSeparator:
     case SegmentSeparator:
@@ skipping 20 matching lines @@
     case PopDirectionalFormat:
         // ignore these
         break;
     case EuropeanNumber:
         // fall through
     default:
         m_status.last = dirCurrent;
     }
 }
 
-template <class Iterator, class Run>
-inline void BidiResolver<Iterator, Run>::reorderRunsFromLevels(BidiRunList<Run>& runs) const
+template <class Iterator, class Run, class IsolatedRun>
+inline void BidiResolver<Iterator, Run, IsolatedRun>::reorderRunsFromLevels(BidiRunList<Run>& runs) const
 {
     unsigned char levelLow = BidiContext::kMaxLevel;
     unsigned char levelHigh = 0;
     for (Run* run = runs.firstRun(); run; run = run->next()) {
         levelHigh = std::max(run->level(), levelHigh);
         levelLow = std::min(run->level(), levelLow);
     }
 
     // This implements reordering of the line (L2 according to Bidi spec):
     // http://unicode.org/reports/tr9/#L2
@@ skipping 15 matching lines @@
             unsigned start = i;
             for (;i <= count && run && run->level() >= levelHigh; i++)
                 run = run->next();
             unsigned end = i - 1;
             runs.reverseRuns(start, end);
         }
         levelHigh--;
     }
 }
 
-template <class Iterator, class Run>
-TextDirection BidiResolver<Iterator, Run>::determineDirectionalityInternal(
+template <class Iterator, class Run, class IsolatedRun>
+TextDirection BidiResolver<Iterator, Run, IsolatedRun>::determineDirectionalityInternal(
     bool breakOnParagraph, bool* hasStrongDirectionality)
 {
     while (!m_current.atEnd()) {
         if (inIsolate()) {
             increment();
             continue;
         }
         if (breakOnParagraph && m_current.atParagraphSeparator())
             break;
         UChar32 current = m_current.current();
@@ skipping 30 matching lines @@
 }
 
 inline TextDirection directionForCharacter(UChar32 character)
 {
     WTF::Unicode::Direction charDirection = WTF::Unicode::direction(character);
     if (charDirection == WTF::Unicode::RightToLeft || charDirection == WTF::Unicode::RightToLeftArabic)
         return RTL;
     return LTR;
 }
 
-template <class Iterator, class Run>
-void BidiResolver<Iterator, Run>::createBidiRunsForLine(const Iterator& end, VisualDirectionOverride override, bool hardLineBreak, bool reorderRuns)
+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;
 
     ASSERT(m_direction == OtherNeutral);
     m_trailingSpaceRun = 0;
 
     m_endOfLine = end;
 
     if (override != NoVisualOverride) {
         m_emptyRun = false;
@@ skipping 10 matching lines @@
             m_runs.reverseRuns(0, m_runs.runCount() - 1);
         return;
     }
 
     m_emptyRun = true;
 
     m_eor = Iterator();
 
     m_last = m_current;
     bool lastLineEnded = false;
-    BidiResolver<Iterator, Run> stateAtEnd;
+    BidiResolver<Iterator, Run, IsolatedRun> stateAtEnd;
 
     while (true) {
         if (inIsolate() && m_emptyRun) {
             m_sor = m_current;
             m_emptyRun = false;
         }
 
         if (!lastLineEnded && isEndOfLine(end)) {
             if (m_emptyRun)
                 break;
@@ skipping 356 matching lines @@
     m_runs.setLogicallyLastRun(m_runs.lastRun());
     if (reorderRuns)
         reorderRunsFromLevels(m_runs);
     m_endOfRunAtEndOfLine = Iterator();
     m_endOfLine = Iterator();
 
     if (!hardLineBreak && m_runs.runCount())
         applyL1Rule(m_runs);
 }
 
-template <class Iterator, class Run>
-void BidiResolver<Iterator, Run>::setMidpointStateForIsolatedRun(Run* run, const MidpointState<Iterator>& midpoint)
+template <class Iterator, class Run, class IsolatedRun>
+void BidiResolver<Iterator, Run, IsolatedRun>::setMidpointStateForIsolatedRun(Run& run, const MidpointState<Iterator>& midpoint)
 {
-    ASSERT(!m_midpointStateForIsolatedRun.contains(run));
-    m_midpointStateForIsolatedRun.add(run, midpoint);
+    ASSERT(!m_midpointStateForIsolatedRun.contains(&run));
+    m_midpointStateForIsolatedRun.add(&run, midpoint);
 }
 
-template<class Iterator, class Run>
-MidpointState<Iterator> BidiResolver<Iterator, Run>::midpointStateForIsolatedRun(Run* run)
+template<class Iterator, class Run, class IsolatedRun>
+MidpointState<Iterator> BidiResolver<Iterator, Run, IsolatedRun>::midpointStateForIsolatedRun(Run& run)
 {
-    return m_midpointStateForIsolatedRun.take(run);
+    return m_midpointStateForIsolatedRun.take(&run);
 }
 
-
 } // namespace blink
 
 #endif // BidiResolver_h