Set m_obj as private member variable

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 53 matching lines @@
     }
 
     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; }
+
     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;
 
-    // FIXME: These should be private.
+// FIXME: These should be private.
 public:
-    RenderObject* m_obj;
     unsigned m_pos;
     int m_nextBreakablePosition;
 };
 
 inline bool operator==(const InlineIterator& it1, const InlineIterator& it2)
 {
-    return it1.m_pos == it2.m_pos && it1.m_obj == it2.m_obj;
+    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.m_obj != it2.m_obj;
+    return it1.m_pos != it2.m_pos || it1.object() != it2.object();
 }
 
 static inline WTF::Unicode::Direction embedCharFromDirection(TextDirection dir, EUnicodeBidi unicodeBidi)
 {
     using namespace WTF::Unicode;
     if (unicodeBidi == Embed)
         return dir == RTL ? RightToLeftEmbedding : LeftToRightEmbedding;
     return dir == RTL ? RightToLeftOverride : LeftToRightOverride;
 }
 
@@ skipping 290 matching lines @@
 
 template<>
 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.m_obj == end.m_obj);
+    bool inEndOfLine = m_current == end || m_current.atEnd() || (inIsolate() && m_current.object() == end.object());
     if (inIsolate() && inEndOfLine) {
-        m_current.moveTo(m_current.m_obj, end.m_pos, m_current.m_nextBreakablePosition);
+        m_current.moveTo(m_current.object(), end.m_pos, m_current.m_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 111 matching lines @@
 {
     if (start > end || RenderBlockFlow::shouldSkipCreatingRunsForObject(obj))
         return;
 
     LineMidpointState& lineMidpointState = resolver.midpointState();
     bool haveNextMidpoint = (lineMidpointState.currentMidpoint < lineMidpointState.numMidpoints);
     InlineIterator nextMidpoint;
     if (haveNextMidpoint)
         nextMidpoint = lineMidpointState.midpoints[lineMidpointState.currentMidpoint];
     if (lineMidpointState.betweenMidpoints) {
-        if (!(haveNextMidpoint && nextMidpoint.m_obj == obj))
+        if (!(haveNextMidpoint && nextMidpoint.object() == obj))
             return;
         // This is a new start point. Stop ignoring objects and
         // adjust our start.
         lineMidpointState.betweenMidpoints = false;
         start = nextMidpoint.m_pos;
         lineMidpointState.currentMidpoint++;
         if (start < end)
             return adjustMidpointsAndAppendRunsForObjectIfNeeded(obj, start, end, resolver, behavior, tracker);
     } else {
-        if (!haveNextMidpoint || (obj != nextMidpoint.m_obj)) {
+        if (!haveNextMidpoint || (obj != nextMidpoint.object())) {
             appendRunObjectIfNecessary(obj, start, end, resolver, behavior, tracker);
             return;
         }
 
         // An end midpoint has been encountered within our object. We
         // need to go ahead and append a run with our endpoint.
         if (nextMidpoint.m_pos + 1 <= end) {
             lineMidpointState.betweenMidpoints = true;
             lineMidpointState.currentMidpoint++;
             if (nextMidpoint.m_pos != UINT_MAX) { // UINT_MAX means stop at the object and don't nclude any of it.
@@ skipping 15 matching lines @@
 
 template <>
 inline void InlineBidiResolver::appendRun()
 {
     if (!m_emptyRun && !m_eor.atEnd() && !m_reachedEndOfLine) {
         // Keep track of when we enter/leave "unicode-bidi: isolate" inlines.
         // Initialize our state depending on if we're starting in the middle of such an inline.
         // FIXME: Could this initialize from this->inIsolate() instead of walking up the render tree?
         IsolateTracker isolateTracker(numberOfIsolateAncestors(m_sor));
         int start = m_sor.m_pos;
-        RenderObject* obj = m_sor.m_obj;
-        while (obj && obj != m_eor.m_obj && obj != m_endOfRunAtEndOfLine.m_obj) {
+        RenderObject* obj = m_sor.object();
+        while (obj && obj != m_eor.object() && obj != m_endOfRunAtEndOfLine.object()) {
             if (isolateTracker.inIsolate())
                 addFakeRunIfNecessary(obj, start, obj->length(), *this, isolateTracker);
             else
                 adjustMidpointsAndAppendRunsForObjectIfNeeded(obj, start, obj->length(), *this, AppendingRunsForObject, isolateTracker);
             // FIXME: start/obj should be an InlineIterator instead of two separate variables.
             start = 0;
             obj = bidiNextSkippingEmptyInlines(m_sor.root(), obj, &isolateTracker);
         }
-        bool isEndOfLine = obj == m_endOfLine.m_obj && !m_endOfLine.m_pos;
+        bool isEndOfLine = obj == m_endOfLine.object() && !m_endOfLine.m_pos;
         if (obj && !isEndOfLine) {
-            unsigned pos = obj == m_eor.m_obj ? m_eor.m_pos : INT_MAX;
-            if (obj == m_endOfRunAtEndOfLine.m_obj && m_endOfRunAtEndOfLine.m_pos <= pos) {
+            unsigned pos = obj == m_eor.object() ? m_eor.m_pos : INT_MAX;
+            if (obj == m_endOfRunAtEndOfLine.object() && m_endOfRunAtEndOfLine.m_pos <= pos) {
                 m_reachedEndOfLine = true;
                 pos = m_endOfRunAtEndOfLine.m_pos;
             }
             // It's OK to add runs for zero-length RenderObjects, just don't make the run larger than it should be
             int end = obj->length() ? pos + 1 : 0;
             if (isolateTracker.inIsolate())
                 addFakeRunIfNecessary(obj, start, end, *this, isolateTracker);
             else
                 adjustMidpointsAndAppendRunsForObjectIfNeeded(obj, start, end, *this, AppendingRunsForObject, isolateTracker);
         }
 
         if (isEndOfLine)
             m_reachedEndOfLine = true;
         m_eor.increment();
         m_sor = m_eor;
     }
 
     m_direction = WTF::Unicode::OtherNeutral;
     m_status.eor = WTF::Unicode::OtherNeutral;
 }
 
 }
 
 #endif // InlineIterator_h