Implement unicode bidi P2 and P3 rules in BidiResolver

Source/core/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 205 matching lines @@
     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(); }
 
+    TextDirection determineParagraphDirectionality(bool* hasStrongDirectionality = 0);
+
 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.
@@ skipping 282 matching lines @@
             for (;i <= count && run && run->level() >= levelHigh; i++)
                 run = run->next();
             unsigned end = i - 1;
             m_runs.reverseRuns(start, end);
         }
         levelHigh--;
     }
 }
 
 template <class Iterator, class Run>
+TextDirection BidiResolver<Iterator, Run>::determineParagraphDirectionality(bool* hasStrongDirectionality)
+{
+    while (!m_current.atEnd()) {
+        if (inIsolate()) {
+            increment();
+            continue;
+        }
+        if (m_current.atParagraphSeparator())
+            break;
+        if (UChar current = m_current.current()) {
+            WTF::Unicode::Direction charDirection = WTF::Unicode::direction(current);
+            if (charDirection == WTF::Unicode::LeftToRight) {
+                if (hasStrongDirectionality)
+                    *hasStrongDirectionality = true;
+                return LTR;
+            }
+            if (charDirection == WTF::Unicode::RightToLeft || charDirection == WTF::Unicode::RightToLeftArabic) {
+                if (hasStrongDirectionality)
+                    *hasStrongDirectionality = true;
+                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)
 {
     using namespace WTF::Unicode;
 
     ASSERT(m_direction == OtherNeutral);
 
     if (override != NoVisualOverride) {
         m_emptyRun = false;
         m_sor = m_current;
         m_eor = Iterator();
@@ skipping 381 matching lines @@
     }
 
     m_runs.setLogicallyLastRun(m_runs.lastRun());
     reorderRunsFromLevels();
     endOfLine = Iterator();
 }
 
 } // namespace WebCore
 
 #endif // BidiResolver_h