Set m_nextBreakablePosition as private in InlineIterator, and use it

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 25 matching lines @@
 class InlineIterator {
 public:
     enum IncrementRule {
         FastIncrementInIsolatedRenderer,
         FastIncrementInTextNode
     };
 
     InlineIterator()
         : m_root(0)
         , m_obj(0)
+        , m_nextBreakablePosition(-1)
         , m_pos(0)
-        , m_nextBreakablePosition(-1)
     {
     }
 
     InlineIterator(RenderObject* root, RenderObject* o, unsigned p)
         : m_root(root)
         , m_obj(o)
+        , m_nextBreakablePosition(-1)
         , m_pos(p)
-        , m_nextBreakablePosition(-1)
     {
     }
 
     void clear() { moveTo(0, 0); }
 
     void moveToStartOf(RenderObject* object)
     {
         moveTo(object, 0);
     }
 
     void moveTo(RenderObject* object, unsigned offset, int nextBreak = -1)
     {
         m_obj = object;
         m_pos = offset;
         m_nextBreakablePosition = nextBreak;
     }
 
     RenderObject* object() const { return m_obj; }
     void setObject(RenderObject* object) { m_obj = object; }
 
+    int nextBreakablePosition() const { return m_nextBreakablePosition; }
+    void setNextBreakablePosition(int position) { m_nextBreakablePosition = position; }
+
     unsigned offset() const { return m_pos; }
     RenderObject* root() const { return m_root; }
 
     void fastIncrementInTextNode();
     void increment(InlineBidiResolver* = 0, IncrementRule = FastIncrementInTextNode);
     bool atEnd() const;
 
     inline bool atTextParagraphSeparator() const
     {
         return m_obj && m_obj->preservesNewline() && m_obj->isText() && toRenderText(m_obj)->textLength()
             && !toRenderText(m_obj)->isWordBreak() && toRenderText(m_obj)->characterAt(m_pos) == '\n';
     }
 
     inline bool atParagraphSeparator() const
     {
         return (m_obj && m_obj->isBR()) || atTextParagraphSeparator();
     }
 
     UChar characterAt(unsigned) const;
     UChar current() const;
     UChar previousInSameNode() const;
     ALWAYS_INLINE WTF::Unicode::Direction direction() const;
 
 private:
     RenderObject* m_root;
     RenderObject* m_obj;
 
+    int m_nextBreakablePosition;
+
 // FIXME: These should be private.
 public:
     unsigned m_pos;
-    int m_nextBreakablePosition;
 };
 
 inline bool operator==(const InlineIterator& it1, const InlineIterator& it2)
 {
     return it1.m_pos == it2.m_pos && it1.object() == it2.object();
 }
 
 inline bool operator!=(const InlineIterator& it1, const InlineIterator& it2)
 {
     return it1.m_pos != it2.m_pos || it1.object() != it2.object();
@@ skipping 318 matching lines @@
 inline void InlineBidiResolver::increment()
 {
     m_current.increment(this, InlineIterator::FastIncrementInIsolatedRenderer);
 }
 
 template <>
 inline bool InlineBidiResolver::isEndOfLine(const InlineIterator& end)
 {
     bool inEndOfLine = m_current == end || m_current.atEnd() || (inIsolate() && m_current.object() == end.object());
     if (inIsolate() && inEndOfLine) {
-        m_current.moveTo(m_current.object(), end.m_pos, m_current.m_nextBreakablePosition);
+        m_current.moveTo(m_current.object(), end.m_pos, m_current.nextBreakablePosition());
         m_last = m_current;
         updateStatusLastFromCurrentDirection(WTF::Unicode::OtherNeutral);
     }
     return inEndOfLine;
 }
 
 static inline bool isIsolatedInline(RenderObject* object)
 {
     ASSERT(object);
     return object->isRenderInline() && isIsolated(object->style()->unicodeBidi());
@@ skipping 195 matching lines @@
         m_sor = m_eor;
     }
 
     m_direction = WTF::Unicode::OtherNeutral;
     m_status.eor = WTF::Unicode::OtherNeutral;
 }
 
 }
 
 #endif // InlineIterator_h