Finish making FloatingObject a real class with private members

Source/core/rendering/RenderBlock.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple 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 636 matching lines @@
             , rect(LayoutRect(f->x() - f->marginLeft(), f->y() - f->marginTop(), f->width() + f->marginWidth(), f->height() + f->marginHeight()))
             , everHadLayout(f->everHadLayout())
         {
         }
 
         RenderBox* object;
         LayoutRect rect;
         bool everHadLayout;
     };
 
-    struct FloatingObject {
+    class FloatingObject {
         WTF_MAKE_NONCOPYABLE(FloatingObject); WTF_MAKE_FAST_ALLOCATED;
     public:
         // Note that Type uses bits so you can use FloatLeftRight as a mask to query for both left and right.
         enum Type { FloatLeft = 1, FloatRight = 2, FloatLeftRight = 3 };
 
         FloatingObject(EFloat type)
             : m_renderer(0)
             , m_originatingLine(0)
             , m_paginationStrut(0)
             , m_shouldPaint(true)
@@ skipping 51 matching lines @@
         inline LayoutUnit height() const { return m_frameRect.height(); }
 
         void setX(LayoutUnit x) { ASSERT(!isInPlacedTree()); m_frameRect.setX(x); }
         void setY(LayoutUnit y) { ASSERT(!isInPlacedTree()); m_frameRect.setY(y); }
         void setWidth(LayoutUnit width) { ASSERT(!isInPlacedTree()); m_frameRect.setWidth(width); }
         void setHeight(LayoutUnit height) { ASSERT(!isInPlacedTree()); m_frameRect.setHeight(height); }
 
         const LayoutRect& frameRect() const { ASSERT(isPlaced()); return m_frameRect; }
         void setFrameRect(const LayoutRect& frameRect) { ASSERT(!isInPlacedTree()); m_frameRect = frameRect; }
 
+        int paginationStrut() const { return m_paginationStrut; }
+        void setPaginationStrut(int strut) { m_paginationStrut = strut; }
+
 #ifndef NDEBUG
         bool isInPlacedTree() const { return m_isInPlacedTree; }
         void setIsInPlacedTree(bool value) { m_isInPlacedTree = value; }
 #endif
 
         bool shouldPaint() const { return m_shouldPaint; }
         void setShouldPaint(bool shouldPaint) { m_shouldPaint = shouldPaint; }
         bool isDescendant() const { return m_isDescendant; }
         void setIsDescendant(bool isDescendant) { m_isDescendant = isDescendant; }
 
+        // FIXME: Callers of these methods are dangerous and should be whitelisted explicitly or removed.
+        void setRenderer(RenderBox* renderer) { m_renderer = renderer; }
+        RootInlineBox* originatingLine() const { return m_originatingLine; }
+        void setOriginatingLine(RootInlineBox* line) { m_originatingLine = line; }
+
+    private:
         RenderBox* m_renderer;
         RootInlineBox* m_originatingLine;
         LayoutRect m_frameRect;
-        int m_paginationStrut;
+        int m_paginationStrut; // FIXME: Is this class size-sensitive? Does this need 32-bits?
 
-    private:
         unsigned m_type : 2; // Type (left or right aligned)
         unsigned m_shouldPaint : 1;
         unsigned m_isDescendant : 1;
         unsigned m_isPlaced : 1;
 #ifndef NDEBUG
         unsigned m_isInPlacedTree : 1;
 #endif
     };
 
     LayoutPoint flipFloatForWritingModeForChild(const FloatingObject*, const LayoutPoint&) const;
@@ skipping 387 matching lines @@
 
     virtual bool canCollapseAnonymousBlockChild() const { return true; }
 
 public:
     LayoutUnit offsetFromLogicalTopOfFirstPage() const;
     RenderRegion* regionAtBlockOffset(LayoutUnit) const;
     RenderRegion* clampToStartAndEndRegions(RenderRegion*) const;
 
 protected:
     struct FloatingObjectHashFunctions {
-        static unsigned hash(FloatingObject* key) { return DefaultHash<RenderBox*>::Hash::hash(key->m_renderer); }
-        static bool equal(FloatingObject* a, FloatingObject* b) { return a->m_renderer == b->m_renderer; }
+        static unsigned hash(FloatingObject* key) { return DefaultHash<RenderBox*>::Hash::hash(key->renderer()); }
+        static bool equal(FloatingObject* a, FloatingObject* b) { return a->renderer() == b->renderer(); }
         static const bool safeToCompareToEmptyOrDeleted = true;
     };
     struct FloatingObjectHashTranslator {
         static unsigned hash(RenderBox* key) { return DefaultHash<RenderBox*>::Hash::hash(key); }
-        static bool equal(FloatingObject* a, RenderBox* b) { return a->m_renderer == b; }
+        static bool equal(FloatingObject* a, RenderBox* b) { return a->renderer() == b; }
     };
     typedef ListHashSet<FloatingObject*, 4, FloatingObjectHashFunctions> FloatingObjectSet;
     typedef FloatingObjectSet::const_iterator FloatingObjectSetIterator;
     typedef PODInterval<int, FloatingObject*> FloatingObjectInterval;
     typedef PODIntervalTree<int, FloatingObject*> FloatingObjectTree;
     typedef PODFreeListArena<PODRedBlackTree<FloatingObjectInterval>::Node> IntervalArena;
 
     template <FloatingObject::Type FloatTypeValue>
     class FloatIntervalSearchAdapter {
     public:
@@ skipping 173 matching lines @@
     static String string(const int value);
 };
 template<> struct ValueToString<RenderBlock::FloatingObject*> {
     static String string(const RenderBlock::FloatingObject*);
 };
 #endif
 
 } // namespace WebCore
 
 #endif // RenderBlock_h