Oilpan: Remove most WillBe types from the code base

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 2014 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 28 matching lines @@
 #include "wtf/text/AtomicString.h"
 
 namespace blink {
 
 class ShareableElementData;
 class StylePropertySet;
 class UniqueElementData;
 
 // ElementData represents very common, but not necessarily unique to an element,
 // data such as attributes, inline style, and parsed class names and ids.
-class ElementData : public RefCountedWillBeGarbageCollectedFinalized<ElementData> {
-    USING_FAST_MALLOC_WILL_BE_REMOVED(ElementData);
+class ElementData : public GarbageCollectedFinalized<ElementData> {
 public:
 #if ENABLE(OILPAN)
     // Override GarbageCollectedFinalized's finalizeGarbageCollectedObject to
     // dispatch to the correct subclass destructor.
     void finalizeGarbageCollectedObject();
 #else
     // Override RefCounted's deref() to ensure operator delete is called on
     // the appropriate subclass type.
     void deref();
 #endif
@@ skipping 26 matching lines @@
     explicit ElementData(unsigned arraySize);
     ElementData(const ElementData&, bool isUnique);
 
     // Keep the type in a bitfield instead of using virtual destructors to avoid adding a vtable.
     unsigned m_isUnique : 1;
     unsigned m_arraySize : 28;
     mutable unsigned m_presentationAttributeStyleIsDirty : 1;
     mutable unsigned m_styleAttributeIsDirty : 1;
     mutable unsigned m_animatedSVGAttributesAreDirty : 1;
 
-    mutable RefPtrWillBeMember<StylePropertySet> m_inlineStyle;
+    mutable Member<StylePropertySet> m_inlineStyle;
     mutable SpaceSplitString m_classNames;
     mutable AtomicString m_idForStyleResolution;
 
 private:
     friend class Element;
     friend class ShareableElementData;
     friend class UniqueElementData;
     friend class SVGElement;
 
 #if !ENABLE(OILPAN)
     void destroy();
 #endif
 
-    PassRefPtrWillBeRawPtr<UniqueElementData> makeUniqueCopy() const;
+    RawPtr<UniqueElementData> makeUniqueCopy() const;
 };
 
 #define DEFINE_ELEMENT_DATA_TYPE_CASTS(thisType,  pointerPredicate, referencePredicate) \
     template<typename T> inline thisType* to##thisType(const RefPtr<T>& data) { return to##thisType(data.get()); } \
     DEFINE_TYPE_CASTS(thisType, ElementData, data, pointerPredicate, referencePredicate)
 
 #if COMPILER(MSVC)
 #pragma warning(push)
 #pragma warning(disable: 4200) // Disable "zero-sized array in struct/union" warning
 #endif
 
 // SharableElementData is managed by ElementDataCache and is produced by
 // the parser during page load for elements that have identical attributes. This
 // is a memory optimization since it's very common for many elements to have
 // duplicate sets of attributes (ex. the same classes).
 class ShareableElementData final : public ElementData {
 public:
-    static PassRefPtrWillBeRawPtr<ShareableElementData> createWithAttributes(const Vector<Attribute>&);
+    static RawPtr<ShareableElementData> createWithAttributes(const Vector<Attribute>&);
 
     explicit ShareableElementData(const Vector<Attribute>&);
     explicit ShareableElementData(const UniqueElementData&);
     ~ShareableElementData();
 
     DEFINE_INLINE_TRACE_AFTER_DISPATCH() { ElementData::traceAfterDispatch(visitor); }
 
     // Add support for placement new as ShareableElementData is not allocated
     // with a fixed size. Instead the allocated memory size is computed based on
     // the number of attributes. This requires us to use Heap::allocate directly
@@ skipping 16 matching lines @@
 #endif
 
 // UniqueElementData is created when an element needs to mutate its attributes
 // or gains presentation attribute style (ex. width="10"). It does not need to
 // be created to fill in values in the ElementData that are derived from
 // attributes. For example populating the m_inlineStyle from the style attribute
 // doesn't require a UniqueElementData as all elements with the same style
 // attribute will have the same inline style.
 class UniqueElementData final : public ElementData {
 public:
-    static PassRefPtrWillBeRawPtr<UniqueElementData> create();
-    PassRefPtrWillBeRawPtr<ShareableElementData> makeShareableCopy() const;
+    static RawPtr<UniqueElementData> create();
+    RawPtr<ShareableElementData> makeShareableCopy() const;
 
     MutableAttributeCollection attributes();
     AttributeCollection attributes() const;
 
     UniqueElementData();
     explicit UniqueElementData(const ShareableElementData&);
     explicit UniqueElementData(const UniqueElementData&);
 
     DECLARE_TRACE_AFTER_DISPATCH();
 
     // FIXME: We might want to support sharing element data for elements with
     // presentation attribute style. Lots of table cells likely have the same
     // attributes. Most modern pages don't use presentation attributes though
     // so this might not make sense.
-    mutable RefPtrWillBeMember<StylePropertySet> m_presentationAttributeStyle;
+    mutable Member<StylePropertySet> m_presentationAttributeStyle;
     AttributeVector m_attributeVector;
 };
 
 DEFINE_ELEMENT_DATA_TYPE_CASTS(UniqueElementData, data->isUnique(), data.isUnique());
 
 #if !ENABLE(OILPAN)
 inline void ElementData::deref()
 {
     if (!derefBase())
         return;
@@ skipping 26 matching lines @@
 }
 
 inline MutableAttributeCollection UniqueElementData::attributes()
 {
     return MutableAttributeCollection(m_attributeVector);
 }
 
 } // namespace blink
 
 #endif // ElementData_h