Rename LayoutStyle to papayawhip

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 17 matching lines @@
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/CoreExport.h"
 #include "core/dom/MutationObserver.h"
 #include "core/dom/SimulatedClickOptions.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/dom/TreeScope.h"
 #include "core/dom/TreeShared.h"
 #include "core/editing/EditingBoundary.h"
 #include "core/events/EventTarget.h"
 #include "core/inspector/InspectorCounters.h"
-#include "core/layout/style/LayoutStyleConstants.h"
+#include "core/layout/style/ComputedStyleConstants.h"
 #include "platform/geometry/LayoutRect.h"
 #include "platform/heap/Handle.h"
 #include "platform/weborigin/KURLHash.h"
 #include "wtf/Forward.h"
 
 // This needs to be here because Document.h also depends on it.
 #define DUMP_NODE_STATISTICS 0
 
 namespace blink {
 
@@ skipping 23 matching lines @@
 class PlatformGestureEvent;
 class PlatformKeyboardEvent;
 class PlatformMouseEvent;
 class PlatformWheelEvent;
 class QualifiedName;
 class RadioNodeList;
 class RegisteredEventListener;
 class LayoutBox;
 class LayoutBoxModelObject;
 class LayoutObject;
-class LayoutStyle;
+class ComputedStyle;
 class SVGQualifiedName;
 class ShadowRoot;
 template <typename NodeType> class StaticNodeTypeList;
 using StaticNodeList = StaticNodeTypeList<Node>;
 class TagCollection;
 class Text;
 class TouchEvent;
 class WeakNodeMap;
 
 const int nodeStyleChangeShift = 19;
@@ skipping 420 matching lines @@
             m_data.m_rareData->setLayoutObject(layoutObject);
         else
             m_data.m_layoutObject = layoutObject;
     }
 
     // Use these two methods with caution.
     LayoutBox* layoutBox() const;
     LayoutBoxModelObject* layoutBoxModelObject() const;
 
     struct AttachContext {
-        LayoutStyle* resolvedStyle;
+        ComputedStyle* resolvedStyle;
         bool performingReattach;
 
         AttachContext() : resolvedStyle(nullptr), performingReattach(false) { }
     };
 
     // Attaches this node to the rendering tree. This calculates the style to be applied to the node and creates an
     // appropriate LayoutObject which will be inserted into the tree (except when the style has display: none). This
     // makes the node visible in the FrameView.
     virtual void attach(const AttachContext& = AttachContext());
 
     // Detaches the node from the rendering tree, making it invisible in the rendered view. This method will remove
     // the node's rendering object from the rendering tree and delete it.
     virtual void detach(const AttachContext& = AttachContext());
 
 #if ENABLE(ASSERT)
     bool inDetach() const;
 #endif
 
     void reattach(const AttachContext& = AttachContext());
     void lazyReattachIfAttached();
 
     // Returns true if recalcStyle should be called on the object, if there is such a method (on Document and Element).
     bool shouldCallRecalcStyle(StyleRecalcChange);
 
     // Wrapper for nodes that don't have a renderer, but still cache the style (like HTMLOptionElement).
-    LayoutStyle* mutableLayoutStyle() const;
-    const LayoutStyle* layoutStyle() const;
-    const LayoutStyle* parentLayoutStyle() const;
+    ComputedStyle* mutableComputedStyle() const;
+    const ComputedStyle* computedStyle() const;
+    const ComputedStyle* parentComputedStyle() const;
 
-    const LayoutStyle& layoutStyleRef() const;
+    const ComputedStyle& computedStyleRef() const;
 
-    const LayoutStyle* computedStyle(PseudoId pseudoElementSpecifier = NOPSEUDO) { return virtualComputedStyle(pseudoElementSpecifier); }
+    const ComputedStyle* ensureComputedStyle(PseudoId pseudoElementSpecifier = NOPSEUDO) { return virtualEnsureComputedStyle(pseudoElementSpecifier); }
 
     // -----------------------------------------------------------------------------
     // Notification of document structure changes (see ContainerNode.h for more notification methods)
     //
     // At first, WebKit notifies the node that it has been inserted into the document. This is called during document parsing, and also
     // when a node is added through the DOM methods insertBefore(), appendChild() or replaceChild(). The call happens _after_ the node has been added to the tree.
     // This is similar to the DOMNodeInsertedIntoDocument DOM event, but does not require the overhead of event
     // dispatching.
     //
     // WebKit notifies this callback regardless if the subtree of the node is a document tree or a floating subtree.
@@ skipping 234 matching lines @@
     bool hasEditableStyle(EditableLevel, UserSelectAllTreatment = UserSelectAllIsAlwaysNonEditable) const;
     bool isEditableToAccessibility(EditableLevel) const;
 
     bool isUserActionElementActive() const;
     bool isUserActionElementInActiveChain() const;
     bool isUserActionElementHovered() const;
     bool isUserActionElementFocused() const;
 
     void setStyleChange(StyleChangeType);
 
-    virtual LayoutStyle* nonRendererStyle() const { return nullptr; }
+    virtual ComputedStyle* nonLayoutObjectComputedStyle() const { return nullptr; }
 
-    virtual const LayoutStyle* virtualComputedStyle(PseudoId = NOPSEUDO);
+    virtual const ComputedStyle* virtualEnsureComputedStyle(PseudoId = NOPSEUDO);
 
     void trackForDebugging();
 
     WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration>>* mutationObserverRegistry();
     WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration>>* transientMutationObserverRegistry();
 
     uint32_t m_nodeFlags;
     RawPtrWillBeMember<ContainerNode> m_parentOrShadowHostNode;
     RawPtrWillBeMember<TreeScope> m_treeScope;
     RawPtrWillBeMember<Node> m_previous;
@@ skipping 83 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