Remove a bit more position:fixed plumbing.

sky/engine/core/rendering/RenderObject.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2009 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
@@ skipping 603 matching lines @@
     // Set the style of the object and update the state of the object accordingly.
     void setStyle(PassRefPtr<RenderStyle>);
 
     // Updates only the local style ptr of the object.  Does not update the state of the object,
     // and so only should be called when the style is known not to have changed (or from setStyle).
     void setStyleInternal(PassRefPtr<RenderStyle> style) { m_style = style; }
 
     // returns the containing block level element for this element.
     RenderBlock* containingBlock() const;
 
-    bool canContainFixedPositionObjects() const
-    {
-        return isRenderView() || (hasTransform() && isRenderBlock());
-    }
-
     // Convert the given local point to absolute coordinates
     // FIXME: Temporary. If UseTransforms is true, take transforms into account. Eventually localToAbsolute() will always be transform-aware.
     FloatPoint localToAbsolute(const FloatPoint& localPoint = FloatPoint(), MapCoordinatesFlags = 0) const;
     FloatPoint absoluteToLocal(const FloatPoint&, MapCoordinatesFlags = 0) const;
 
     // Convert a local quad to absolute coordinates, taking transforms into account.
     FloatQuad localToAbsoluteQuad(const FloatQuad& quad, MapCoordinatesFlags mode = 0) const
     {
         return localToContainerQuad(quad, 0, mode);
     }
@@ skipping 365 matching lines @@
     void checkBlockPositionedObjectsNeedLayout();
 #endif
     const char* invalidationReasonToString(InvalidationReason) const;
 
     void markContainingBlockChainForPaintInvalidation()
     {
         for (RenderObject* container = this->container(); container && !container->shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState(); container = container->container())
             container->setMayNeedPaintInvalidation(true);
     }
 
+    // FIXME(sky): This method is just to avoid copy-paste.
+    // Merge container into containingBlock and then get rid of this method.
+    bool canContainAbsolutePositionObjects() const
+    {
+        return isRenderView() || (hasTransform() && isRenderBlock());
+    }
+
     static bool isAllowedToModifyRenderTreeStructure(Document&);
 
     RefPtr<RenderStyle> m_style;
 
     RawPtr<Node> m_node;
 
     RawPtr<RenderObject> m_parent;
     RawPtr<RenderObject> m_previous;
     RawPtr<RenderObject> m_next;
 
 #if ENABLE(ASSERT)
     unsigned m_setNeedsLayoutForbidden : 1;
 #if ENABLE(OILPAN)
 protected:
     unsigned m_didCallDestroy          : 1;
 private:
 #endif
 #endif
 
 #define ADD_BOOLEAN_BITFIELD(name, Name) \
     private:\
         unsigned m_##name : 1;\
     public:\
         bool name() const { return m_##name; }\
         void set##Name(bool name) { m_##name = name; }\
 
     class RenderObjectBitfields {
+        // FIXME(sky): Remove this enum and just use EPosition directly.
         enum PositionedState {
             IsStaticallyPositioned = 0,
             IsRelativelyPositioned = 1,
             IsOutOfFlowPositioned = 2,
         };
 
     public:
         RenderObjectBitfields(Node* node)
             : m_selfNeedsLayout(false)
             , m_shouldDoFullPaintInvalidation(false)
@@ skipping 83 matching lines @@
         unsigned m_selectionState : 3; // SelectionState
         unsigned m_boxDecorationBackgroundState : 2; // BoxDecorationBackgroundState
 
     public:
         bool isOutOfFlowPositioned() const { return m_positionedState == IsOutOfFlowPositioned; }
         bool isRelPositioned() const { return m_positionedState == IsRelativelyPositioned; }
         bool isPositioned() const { return m_positionedState != IsStaticallyPositioned; }
 
         void setPositionedState(int positionState)
         {
-            // FIXME(sky): Simplify now that we don't have FixedPosition.
-            // This mask maps FixedPosition and AbsolutePosition to IsOutOfFlowPositioned, saving one bit.
-            m_positionedState = static_cast<PositionedState>(positionState & 0x3);
+            m_positionedState = static_cast<PositionedState>(positionState);
         }
         void clearPositionedState() { m_positionedState = StaticPosition; }
 
         ALWAYS_INLINE SelectionState selectionState() const { return static_cast<SelectionState>(m_selectionState); }
         ALWAYS_INLINE void setSelectionState(SelectionState selectionState) { m_selectionState = selectionState; }
 
         ALWAYS_INLINE BoxDecorationBackgroundState boxDecorationBackgroundState() const { return static_cast<BoxDecorationBackgroundState>(m_boxDecorationBackgroundState); }
         ALWAYS_INLINE void setBoxDecorationBackgroundState(BoxDecorationBackgroundState s) { m_boxDecorationBackgroundState = s; }
     };
 
@@ skipping 188 matching lines @@
 void showTree(const blink::RenderObject*);
 void showLineTree(const blink::RenderObject*);
 void showRenderTree(const blink::RenderObject* object1);
 // We don't make object2 an optional parameter so that showRenderTree
 // can be called from gdb easily.
 void showRenderTree(const blink::RenderObject* object1, const blink::RenderObject* object2);
 
 #endif
 
 #endif // RenderObject_h