Fix text-align: center/right when line wraps at atomic inline and spaces

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 203 matching lines @@
 class BidiResolver final {
   DISALLOW_NEW();
   WTF_MAKE_NONCOPYABLE(BidiResolver);
 
  public:
   BidiResolver()
       : m_direction(WTF::Unicode::OtherNeutral),
         m_reachedEndOfLine(false),
         m_emptyRun(true),
         m_nestedIsolateCount(0),
-        m_trailingSpaceRun(0) {}
+        m_trailingSpaceRun(0),
+        m_needsTrailingSpace(false) {}
 
 #if DCHECK_IS_ON()
   ~BidiResolver();
 #endif
 
   const Iterator& position() const { return m_current; }
   Iterator& position() { return m_current; }
   void setPositionIgnoringNestedIsolates(const Iterator& position) {
     m_current = position;
   }
@@ skipping 69 matching lines @@
     bool breakOnParagraph = false;
     return determineDirectionalityInternal(breakOnParagraph,
                                            hasStrongDirectionality);
   }
 
   void setMidpointStateForIsolatedRun(Run&, const MidpointState<Iterator>&);
   MidpointState<Iterator> midpointStateForIsolatedRun(Run&);
 
   Iterator endOfLine() const { return m_endOfLine; }
 
+  void setNeedsTrailingSpace(bool value) { m_needsTrailingSpace = value; }
   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>&);
 
   Run* addTrailingRun(BidiRunList<Run>&,
@@ skipping 21 matching lines @@
 
   // 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<IsolatedRun> m_isolatedRuns;
   Run* m_trailingSpaceRun;
+  bool m_needsTrailingSpace;
   TextDirection m_paragraphDirectionality;
 
  private:
   void raiseExplicitEmbeddingLevel(BidiRunList<Run>&,
                                    WTF::Unicode::CharDirection from,
                                    WTF::Unicode::CharDirection to);
   void lowerExplicitEmbeddingLevel(BidiRunList<Run>&,
                                    WTF::Unicode::CharDirection from);
   void checkDirectionInLowerRaiseEmbeddingLevel();
 
   void updateStatusLastFromCurrentDirection(WTF::Unicode::CharDirection);
   void reorderRunsFromLevels(BidiRunList<Run>&) const;
 
-  bool needsToApplyL1Rule(BidiRunList<Run>&) { return false; }
+  bool needsTrailingSpace(BidiRunList<Run>&) { return m_needsTrailingSpace; }
   int findFirstTrailingSpaceAtRun(Run*) { return 0; }
   // http://www.unicode.org/reports/tr9/#L1
-  void applyL1Rule(BidiRunList<Run>&);
+  void computeTrailingSpace(BidiRunList<Run>&);
 
   TextDirection determineDirectionalityInternal(bool breakOnParagraph,
                                                 bool* hasStrongDirectionality);
 
   Vector<BidiEmbedding, 8> m_currentExplicitEmbeddingSequence;
   HashMap<Run*, MidpointState<Iterator>> m_midpointStateForIsolatedRun;
 };
 
 #if DCHECK_IS_ON()
 template <class Iterator, class Run, class IsolatedRun>
@@ skipping 153 matching lines @@
 
   appendRun(runs);
   m_emptyRun = true;
 
   setLastDir(to);
   setLastStrongDir(to);
   m_eor = Iterator();
 }
 
 template <class Iterator, class Run, class IsolatedRun>
-void BidiResolver<Iterator, Run, IsolatedRun>::applyL1Rule(
+void BidiResolver<Iterator, Run, IsolatedRun>::computeTrailingSpace(
     BidiRunList<Run>& runs) {
   ASSERT(runs.runCount());
-  if (!needsToApplyL1Rule(runs))
-    return;
 
   Run* trailingSpaceRun = runs.logicallyLastRun();
 
   int firstSpace = findFirstTrailingSpaceAtRun(trailingSpaceRun);
   if (firstSpace == trailingSpaceRun->stop())
     return;
 
   bool shouldReorder =
       trailingSpaceRun != (m_paragraphDirectionality == TextDirection::kLtr
                                ? runs.lastRun()
                                : runs.firstRun());
   if (firstSpace != trailingSpaceRun->start()) {
     BidiContext* baseContext = context();
     while (BidiContext* parent = baseContext->parent())
       baseContext = parent;
 
     m_trailingSpaceRun = addTrailingRun(
         runs, firstSpace, trailingSpaceRun->m_stop, trailingSpaceRun,
         baseContext, m_paragraphDirectionality);
     ASSERT(m_trailingSpaceRun);
     trailingSpaceRun->m_stop = firstSpace;
     return;
   }
   if (!shouldReorder) {
     m_trailingSpaceRun = trailingSpaceRun;
     return;
   }
 
+  // Apply L1 rule.
   if (m_paragraphDirectionality == TextDirection::kLtr) {
     runs.moveRunToEnd(trailingSpaceRun);
     trailingSpaceRun->m_level = 0;
   } else {
     runs.moveRunToBeginning(trailingSpaceRun);
     trailingSpaceRun->m_level = 1;
   }
   m_trailingSpaceRun = trailingSpaceRun;
 }
 
@@ skipping 608 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);
+  if (!hardLineBreak && m_runs.runCount() && needsTrailingSpace(m_runs)) {
+    computeTrailingSpace(m_runs);
+  }
 }
 
 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.insert(&run, midpoint);
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 MidpointState<Iterator>
 BidiResolver<Iterator, Run, IsolatedRun>::midpointStateForIsolatedRun(
     Run& run) {
   return m_midpointStateForIsolatedRun.take(&run);
 }
 
 }  // namespace blink
 
 #endif  // BidiResolver_h