Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/dom/ElementRareData.h

 /*
  * Copyright (C) 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Smith <catfish.man@gmail.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
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 34 matching lines @@
 
 class ElementRareData : public NodeRareData {
 public:
     static ElementRareData* create(LayoutObject* layoutObject)
     {
         return new ElementRareData(layoutObject);
     }
 
     ~ElementRareData();
 
-    void setPseudoElement(PseudoId, PassRefPtrWillBeRawPtr<PseudoElement>);
+    void setPseudoElement(PseudoId, RawPtr<PseudoElement>);
     PseudoElement* pseudoElement(PseudoId) const;
 
     short tabIndex() const { return m_tabindex; }
 
     void setTabIndexExplicitly(short index)
     {
         m_tabindex = index;
         setElementFlag(TabIndexWasSetExplicitly, true);
     }
 
     void clearTabIndexExplicitly()
     {
         m_tabindex = 0;
         clearElementFlag(TabIndexWasSetExplicitly);
     }
 
     CSSStyleDeclaration& ensureInlineCSSStyleDeclaration(Element* ownerElement);
 
     void clearShadow() { m_shadow = nullptr; }
     ElementShadow* shadow() const { return m_shadow.get(); }
     ElementShadow& ensureShadow()
     {
         if (!m_shadow)
             m_shadow = ElementShadow::create();
         return *m_shadow;
     }
 
     NamedNodeMap* attributeMap() const { return m_attributeMap.get(); }
-    void setAttributeMap(PassOwnPtrWillBeRawPtr<NamedNodeMap> attributeMap) { m_attributeMap = attributeMap; }
+    void setAttributeMap(RawPtr<NamedNodeMap> attributeMap) { m_attributeMap = attributeMap; }
 
     ComputedStyle* ensureComputedStyle() const { return m_computedStyle.get(); }
     void setComputedStyle(PassRefPtr<ComputedStyle> computedStyle) { m_computedStyle = computedStyle; }
     void clearComputedStyle() { m_computedStyle = nullptr; }
 
     ClassList* classList() const { return m_classList.get(); }
-    void setClassList(PassOwnPtrWillBeRawPtr<ClassList> classList) { m_classList = classList; }
+    void setClassList(RawPtr<ClassList> classList) { m_classList = classList; }
     void clearClassListValueForQuirksMode()
     {
         if (!m_classList)
             return;
         m_classList->clearValueForQuirksMode();
     }
 
     DatasetDOMStringMap* dataset() const { return m_dataset.get(); }
-    void setDataset(PassOwnPtrWillBeRawPtr<DatasetDOMStringMap> dataset) { m_dataset = dataset; }
+    void setDataset(RawPtr<DatasetDOMStringMap> dataset) { m_dataset = dataset; }
 
     LayoutSize minimumSizeForResizing() const { return m_minimumSizeForResizing; }
     void setMinimumSizeForResizing(LayoutSize size) { m_minimumSizeForResizing = size; }
 
     IntSize savedLayerScrollOffset() const { return m_savedLayerScrollOffset; }
     void setSavedLayerScrollOffset(IntSize size) { m_savedLayerScrollOffset = size; }
 
     ElementAnimations* elementAnimations() { return m_elementAnimations.get(); }
     void setElementAnimations(ElementAnimations* elementAnimations)
     {
         m_elementAnimations = elementAnimations;
     }
 
     bool hasPseudoElements() const;
     void clearPseudoElements();
 
     void incrementCompositorProxiedProperties(uint32_t properties);
     void decrementCompositorProxiedProperties(uint32_t properties);
     CompositorProxiedPropertySet* proxiedPropertyCounts() const { return m_proxiedProperties.get(); }
 
-    void setCustomElementDefinition(PassRefPtrWillBeRawPtr<CustomElementDefinition> definition) { m_customElementDefinition = definition; }
+    void setCustomElementDefinition(RawPtr<CustomElementDefinition> definition) { m_customElementDefinition = definition; }
     CustomElementDefinition* customElementDefinition() const { return m_customElementDefinition.get(); }
 
     AttrNodeList& ensureAttrNodeList();
     AttrNodeList* attrNodeList() { return m_attrNodeList.get(); }
     void removeAttrNodeList() { m_attrNodeList.clear(); }
 
     NodeIntersectionObserverData* intersectionObserverData() const { return m_intersectionObserverData.get(); }
     NodeIntersectionObserverData& ensureIntersectionObserverData()
     {
         if (!m_intersectionObserverData)
             m_intersectionObserverData = new NodeIntersectionObserverData();
         return *m_intersectionObserverData;
     }
 
     DECLARE_TRACE_AFTER_DISPATCH();
 
 private:
     CompositorProxiedPropertySet& ensureCompositorProxiedPropertySet();
     void clearCompositorProxiedPropertySet() { m_proxiedProperties = nullptr; }
 
     short m_tabindex;
 
     LayoutSize m_minimumSizeForResizing;
     IntSize m_savedLayerScrollOffset;
 
-    OwnPtrWillBeMember<DatasetDOMStringMap> m_dataset;
-    OwnPtrWillBeMember<ClassList> m_classList;
-    OwnPtrWillBeMember<ElementShadow> m_shadow;
-    OwnPtrWillBeMember<NamedNodeMap> m_attributeMap;
-    OwnPtrWillBeMember<AttrNodeList> m_attrNodeList;
-    OwnPtrWillBeMember<InlineCSSStyleDeclaration> m_cssomWrapper;
+    Member<DatasetDOMStringMap> m_dataset;
+    Member<ClassList> m_classList;
+    Member<ElementShadow> m_shadow;
+    Member<NamedNodeMap> m_attributeMap;
+    Member<AttrNodeList> m_attrNodeList;
+    Member<InlineCSSStyleDeclaration> m_cssomWrapper;
     OwnPtr<CompositorProxiedPropertySet> m_proxiedProperties;
 
-    PersistentWillBeMember<ElementAnimations> m_elementAnimations;
-    PersistentWillBeMember<NodeIntersectionObserverData> m_intersectionObserverData;
+    Member<ElementAnimations> m_elementAnimations;
+    Member<NodeIntersectionObserverData> m_intersectionObserverData;
 
     RefPtr<ComputedStyle> m_computedStyle;
-    RefPtrWillBeMember<CustomElementDefinition> m_customElementDefinition;
+    Member<CustomElementDefinition> m_customElementDefinition;
 
-    RefPtrWillBeMember<PseudoElement> m_generatedBefore;
-    RefPtrWillBeMember<PseudoElement> m_generatedAfter;
-    RefPtrWillBeMember<PseudoElement> m_generatedFirstLetter;
-    RefPtrWillBeMember<PseudoElement> m_backdrop;
+    Member<PseudoElement> m_generatedBefore;
+    Member<PseudoElement> m_generatedAfter;
+    Member<PseudoElement> m_generatedFirstLetter;
+    Member<PseudoElement> m_backdrop;
 
     explicit ElementRareData(LayoutObject*);
 };
 
 inline LayoutSize defaultMinimumSizeForResizing()
 {
     return LayoutSize(LayoutUnit::max(), LayoutUnit::max());
 }
 
 inline ElementRareData::ElementRareData(LayoutObject* layoutObject)
@@ skipping 25 matching lines @@
 }
 
 inline void ElementRareData::clearPseudoElements()
 {
     setPseudoElement(BEFORE, nullptr);
     setPseudoElement(AFTER, nullptr);
     setPseudoElement(BACKDROP, nullptr);
     setPseudoElement(FIRST_LETTER, nullptr);
 }
 
-inline void ElementRareData::setPseudoElement(PseudoId pseudoId, PassRefPtrWillBeRawPtr<PseudoElement> element)
+inline void ElementRareData::setPseudoElement(PseudoId pseudoId, RawPtr<PseudoElement> element)
 {
     switch (pseudoId) {
     case BEFORE:
         if (m_generatedBefore)
             m_generatedBefore->dispose();
         m_generatedBefore = element;
         break;
     case AFTER:
         if (m_generatedAfter)
             m_generatedAfter->dispose();
@@ skipping 45 matching lines @@
 inline CompositorProxiedPropertySet& ElementRareData::ensureCompositorProxiedPropertySet()
 {
     if (!m_proxiedProperties)
         m_proxiedProperties = CompositorProxiedPropertySet::create();
     return *m_proxiedProperties;
 }
 
 } // namespace blink
 
 #endif // ElementRareData_h