Oilpan: Decrease sizeof(Node) by 8 byte

Source/core/dom/Node.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004-2011, 2014 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * 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
@@ skipping 83 matching lines @@
 
 const int nodeStyleChangeShift = 19;
 
 enum StyleChangeType {
     NoStyleChange = 0,
     LocalStyleChange = 1 << nodeStyleChangeShift,
     SubtreeStyleChange = 2 << nodeStyleChangeShift,
     NeedsReattachStyleChange = 3 << nodeStyleChangeShift,
 };
 
+#if ENABLE(OILPAN) && USE_4BYTE_HEADER_PADDING
+#define NODE_FLAGS reinterpret_cast<HeapObjectHeader*>(reinterpret_cast<uint8_t*>(static_cast<EventTarget*>(const_cast<Node*>(this))) - sizeof(HeapObjectHeader))->m_padding
+#else
+#define NODE_FLAGS m_nodeFlags
+#endif
+
 class NodeRareDataBase {
 public:
     LayoutObject* layoutObject() const { return m_layoutObject; }
     void setLayoutObject(LayoutObject* layoutObject) { m_layoutObject = layoutObject; }
 
 protected:
     NodeRareDataBase(LayoutObject* layoutObject)
         : m_layoutObject(layoutObject)
     { }
 
@@ skipping 233 matching lines @@
     bool inActiveChain() const { return isUserActionElement() && isUserActionElementInActiveChain(); }
     bool hovered() const { return isUserActionElement() && isUserActionElementHovered(); }
     // Note: As a shadow host whose root with delegatesFocus=false may become focused state when
     // an inner element gets focused, in that case more than one elements in a document can return
     // true for |focused()|.  Use Element::isFocusedElementInDocument() or Document::focusedElement()
     // to check which element is exactly focused.
     bool focused() const { return isUserActionElement() && isUserActionElementFocused(); }
 
     bool needsAttach() const { return styleChangeType() == NeedsReattachStyleChange; }
     bool needsStyleRecalc() const { return styleChangeType() != NoStyleChange; }
-    StyleChangeType styleChangeType() const { return static_cast<StyleChangeType>(m_nodeFlags & StyleChangeMask); }
+    StyleChangeType styleChangeType() const { return static_cast<StyleChangeType>(NODE_FLAGS & StyleChangeMask); }
     bool childNeedsStyleRecalc() const { return getFlag(ChildNeedsStyleRecalcFlag); }
     bool isLink() const { return getFlag(IsLinkFlag); }
     bool isEditingText() const { ASSERT(isTextNode()); return getFlag(HasNameOrIsEditingTextFlag); }
 
     void setHasName(bool f) { ASSERT(!isTextNode()); setFlag(f, HasNameOrIsEditingTextFlag); }
     void setChildNeedsStyleRecalc() { setFlag(ChildNeedsStyleRecalcFlag); }
     void clearChildNeedsStyleRecalc() { clearFlag(ChildNeedsStyleRecalcFlag); }
 
     void setNeedsStyleRecalc(StyleChangeType, const StyleChangeReasonForTracing&);
     void clearNeedsStyleRecalc();
@@ skipping 350 matching lines @@
         HasWeakReferencesFlag = 1 << 24,
         V8CollectableDuringMinorGCFlag = 1 << 25,
         HasEventTargetDataFlag = 1 << 26,
         AlreadySpellCheckedFlag = 1 << 27,
 
         DefaultNodeFlags = IsFinishedParsingChildrenFlag | NeedsReattachStyleChange
     };
 
     // 3 bits remaining.
 
-    bool getFlag(NodeFlags mask) const { return m_nodeFlags & mask; }
-    void setFlag(bool f, NodeFlags mask) { m_nodeFlags = (m_nodeFlags & ~mask) | (-(int32_t)f & mask); }
-    void setFlag(NodeFlags mask) { m_nodeFlags |= mask; }
-    void clearFlag(NodeFlags mask) { m_nodeFlags &= ~mask; }
+    bool getFlag(NodeFlags mask) const { return NODE_FLAGS & mask; }
+    void setFlag(bool f, NodeFlags mask) { NODE_FLAGS = (NODE_FLAGS & ~mask) | (-(int32_t)f & mask); }
+    void setFlag(NodeFlags mask) { NODE_FLAGS |= mask; }
+    void clearFlag(NodeFlags mask) { NODE_FLAGS &= ~mask; }
 
 protected:
     enum ConstructionType {
         CreateOther = DefaultNodeFlags,
         CreateText = DefaultNodeFlags | IsTextFlag,
         CreateContainer = DefaultNodeFlags | ChildNeedsStyleRecalcFlag | IsContainerFlag,
         CreateElement = CreateContainer | IsElementFlag,
         CreateShadowRoot = CreateContainer | IsDocumentFragmentFlag | IsInShadowTreeFlag,
         CreateDocumentFragment = CreateContainer | IsDocumentFragmentFlag,
         CreateHTMLElement = CreateElement | IsHTMLFlag,
@@ skipping 61 matching lines @@
 
     virtual ComputedStyle* nonLayoutObjectComputedStyle() const { return nullptr; }
 
     virtual const ComputedStyle* virtualEnsureComputedStyle(PseudoId = NOPSEUDO);
 
     void trackForDebugging();
 
     WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration>>* mutationObserverRegistry();
     WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration>>* transientMutationObserverRegistry();
 
+#if !(ENABLE(OILPAN) && USE_4BYTE_HEADER_PADDING)
     uint32_t m_nodeFlags;
+#endif
     RawPtrWillBeMember<ContainerNode> m_parentOrShadowHostNode;
     RawPtrWillBeMember<TreeScope> m_treeScope;
     RawPtrWillBeMember<Node> m_previous;
     RawPtrWillBeMember<Node> m_next;
     // When a node has rare data we move the layoutObject into the rare data.
     union DataUnion {
         DataUnion() : m_layoutObject(nullptr) { }
         LayoutObject* m_layoutObject;
         NodeRareDataBase* m_rareData;
     } m_data;
@@ skipping 81 matching lines @@
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showNode(const blink::Node*);
 void showTree(const blink::Node*);
 void showNodePath(const blink::Node*);
 #endif
 
 #endif // Node_h