Isolate elements are treated as neutral in UBA however Blink UBA implementation iterates over all t…

Source/core/rendering/InlineIterator.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010 Apple Inc. All right reserved.
  * Copyright (C) 2010 Google Inc. All rights 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.
  *
@@ skipping 18 matching lines @@
 #include "wtf/StdLibExtras.h"
 
 namespace WebCore {
 
 // This class is used to RenderInline subtrees, stepping by character within the
 // text children. InlineIterator will use bidiNext to find the next RenderText
 // optionally notifying a BidiResolver every time it steps into/out of a RenderInline.
 class InlineIterator {
 public:
     enum IncrementRule {
-        FastIncrementInlineRenderer,
+        FastIncrementInIsolatedRenderer,
         FastIncrementInTextNode
     };
 
     InlineIterator()
         : m_root(0)
         , m_obj(0)
         , m_pos(0)
         , m_nextBreakablePosition(-1)
     {
     }
@@ skipping 304 matching lines @@
 private:
     RenderObject* m_root;
     RenderObject* m_current;
     bool m_atEndOfInline;
 };
 
 inline void InlineIterator::increment(InlineBidiResolver* resolver, IncrementRule rule)
 {
     if (!m_obj)
         return;
-    if (m_obj->isText() && rule == FastIncrementInTextNode) {
+
+    if (resolver && resolver->inIsolate() && rule == FastIncrementInIsolatedRenderer) {
+        moveTo(bidiNextSkippingEmptyInlines(m_root, m_obj, resolver), 0);
+        return;
+    }
+
+    if (m_obj->isText()) {
         fastIncrementInTextNode();
         if (m_pos < toRenderText(m_obj)->textLength())
             return;
     }
     // bidiNext can return 0, so use moveTo instead of moveToStartOf
     moveTo(bidiNextSkippingEmptyInlines(m_root, m_obj, resolver), 0);
 }
 
 inline bool InlineIterator::atEnd() const
 {
@@ skipping 28 matching lines @@
 
     if (m_obj && m_obj->isListMarker())
         return m_obj->style()->isLeftToRightDirection() ? WTF::Unicode::LeftToRight : WTF::Unicode::RightToLeft;
 
     return WTF::Unicode::OtherNeutral;
 }
 
 template<>
 inline void InlineBidiResolver::increment()
 {
-    m_current.increment(this);
+    m_current.increment(this, InlineIterator::FastIncrementInIsolatedRenderer);
+}
+
+template <>
+inline bool InlineBidiResolver::isEndOfParagraph(const InlineIterator& end)
+{
+    bool inEndOfParagraph = m_current == end || m_current.atEnd() || (inIsolate() && m_current.m_obj == end.m_obj);
+    if (inIsolate() && inEndOfParagraph) {
+        m_current.moveTo(m_current.m_obj, end.m_pos, m_current.m_nextBreakablePosition);
+        m_last = m_current;
+        updateStatusLastFromCurrentDirection(WTF::Unicode::OtherNeutral);
+    }
+    return inEndOfParagraph;
 }
 
 static inline bool isIsolatedInline(RenderObject* object)
 {
     ASSERT(object);
     return object->isRenderInline() && isIsolated(object->style()->unicodeBidi());
 }
 
 static inline RenderObject* highestContainingIsolateWithinRoot(RenderObject* object, RenderObject* root)
 {
@@ skipping 120 matching lines @@
         m_sor = m_eor;
     }
 
     m_direction = WTF::Unicode::OtherNeutral;
     m_status.eor = WTF::Unicode::OtherNeutral;
 }
 
 }
 
 #endif // InlineIterator_h