Oilpan: Remove most WillBe types from the code base

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
@@ skipping 193 matching lines @@
     ImageDocumentClass = 1 << 2,
     PluginDocumentClass = 1 << 3,
     MediaDocumentClass = 1 << 4,
     SVGDocumentClass = 1 << 5,
     XMLDocumentClass = 1 << 6,
 };
 
 using DocumentClassFlags = unsigned char;
 
 class CORE_EXPORT Document : public ContainerNode, public TreeScope, public SecurityContext, public ExecutionContext
-    , public WillBeHeapSupplementable<Document>, public DocumentLifecycleNotifier {
+    , public HeapSupplementable<Document>, public DocumentLifecycleNotifier {
     DEFINE_WRAPPERTYPEINFO();
-    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(Document);
+    USING_GARBAGE_COLLECTED_MIXIN(Document);
 public:
-    static PassRefPtrWillBeRawPtr<Document> create(const DocumentInit& initializer = DocumentInit())
+    static RawPtr<Document> create(const DocumentInit& initializer = DocumentInit())
     {
-        return adoptRefWillBeNoop(new Document(initializer));
+        return (new Document(initializer));
     }
     ~Document() override;
 
     MediaQueryMatcher& mediaQueryMatcher();
 
     void mediaQueryAffectingValueChanged();
 
 #if !ENABLE(OILPAN)
     using ContainerNode::ref;
     using ContainerNode::deref;
@@ skipping 31 matching lines @@
     bool shouldOverrideLegacyDescription(ViewportDescription::Type);
     void setViewportDescription(const ViewportDescription&);
     const ViewportDescription& viewportDescription() const { return m_viewportDescription; }
     Length viewportDefaultMinWidth() const { return m_viewportDefaultMinWidth; }
 
     bool hasLegacyViewportTag() const { return m_legacyViewportDescription.isLegacyViewportType(); }
 
     String outgoingReferrer() const;
     String outgoingOrigin() const;
 
-    void setDoctype(PassRefPtrWillBeRawPtr<DocumentType>);
+    void setDoctype(RawPtr<DocumentType>);
     DocumentType* doctype() const { return m_docType.get(); }
 
     DOMImplementation& implementation();
 
     Element* documentElement() const
     {
         return m_documentElement.get();
     }
 
     // Returns whether the Document has an AppCache manifest.
     bool hasAppCacheManifest() const;
 
     Location* location() const;
 
-    PassRefPtrWillBeRawPtr<Element> createElement(const AtomicString& name, ExceptionState&);
-    PassRefPtrWillBeRawPtr<DocumentFragment> createDocumentFragment();
-    PassRefPtrWillBeRawPtr<Text> createTextNode(const String& data);
-    PassRefPtrWillBeRawPtr<Comment> createComment(const String& data);
-    PassRefPtrWillBeRawPtr<CDATASection> createCDATASection(const String& data, ExceptionState&);
-    PassRefPtrWillBeRawPtr<ProcessingInstruction> createProcessingInstruction(const String& target, const String& data, ExceptionState&);
-    PassRefPtrWillBeRawPtr<Attr> createAttribute(const AtomicString& name, ExceptionState&);
-    PassRefPtrWillBeRawPtr<Attr> createAttributeNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionState&, bool shouldIgnoreNamespaceChecks = false);
-    PassRefPtrWillBeRawPtr<Node> importNode(Node* importedNode, bool deep, ExceptionState&);
-    PassRefPtrWillBeRawPtr<Element> createElementNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionState&);
-    PassRefPtrWillBeRawPtr<Element> createElement(const QualifiedName&, bool createdByParser);
+    RawPtr<Element> createElement(const AtomicString& name, ExceptionState&);
+    RawPtr<DocumentFragment> createDocumentFragment();
+    RawPtr<Text> createTextNode(const String& data);
+    RawPtr<Comment> createComment(const String& data);
+    RawPtr<CDATASection> createCDATASection(const String& data, ExceptionState&);
+    RawPtr<ProcessingInstruction> createProcessingInstruction(const String& target, const String& data, ExceptionState&);
+    RawPtr<Attr> createAttribute(const AtomicString& name, ExceptionState&);
+    RawPtr<Attr> createAttributeNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionState&, bool shouldIgnoreNamespaceChecks = false);
+    RawPtr<Node> importNode(Node* importedNode, bool deep, ExceptionState&);
+    RawPtr<Element> createElementNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionState&);
+    RawPtr<Element> createElement(const QualifiedName&, bool createdByParser);
 
     Element* elementFromPoint(int x, int y) const;
-    WillBeHeapVector<RawPtrWillBeMember<Element>> elementsFromPoint(int x, int y) const;
-    PassRefPtrWillBeRawPtr<Range> caretRangeFromPoint(int x, int y);
+    HeapVector<Member<Element>> elementsFromPoint(int x, int y) const;
+    RawPtr<Range> caretRangeFromPoint(int x, int y);
     Element* scrollingElement();
 
     String readyState() const;
 
     String defaultCharset() const;
 
     AtomicString characterSet() const { return Document::encodingName(); }
 
     AtomicString encodingName() const;
 
@@ skipping 19 matching lines @@
     void setHasXMLDeclaration(bool hasXMLDeclaration) { m_hasXMLDeclaration = hasXMLDeclaration ? 1 : 0; }
 
     String origin() const { return securityOrigin()->toString(); }
     String suborigin() const { return securityOrigin()->suboriginName(); }
 
     String visibilityState() const;
     PageVisibilityState pageVisibilityState() const;
     bool hidden() const;
     void didChangeVisibilityState();
 
-    PassRefPtrWillBeRawPtr<Node> adoptNode(PassRefPtrWillBeRawPtr<Node> source, ExceptionState&);
+    RawPtr<Node> adoptNode(RawPtr<Node> source, ExceptionState&);
 
-    PassRefPtrWillBeRawPtr<HTMLCollection> images();
-    PassRefPtrWillBeRawPtr<HTMLCollection> embeds();
-    PassRefPtrWillBeRawPtr<HTMLCollection> applets();
-    PassRefPtrWillBeRawPtr<HTMLCollection> links();
-    PassRefPtrWillBeRawPtr<HTMLCollection> forms();
-    PassRefPtrWillBeRawPtr<HTMLCollection> anchors();
-    PassRefPtrWillBeRawPtr<HTMLCollection> scripts();
-    PassRefPtrWillBeRawPtr<HTMLAllCollection> allForBinding();
-    PassRefPtrWillBeRawPtr<HTMLAllCollection> all();
+    RawPtr<HTMLCollection> images();
+    RawPtr<HTMLCollection> embeds();
+    RawPtr<HTMLCollection> applets();
+    RawPtr<HTMLCollection> links();
+    RawPtr<HTMLCollection> forms();
+    RawPtr<HTMLCollection> anchors();
+    RawPtr<HTMLCollection> scripts();
+    RawPtr<HTMLAllCollection> allForBinding();
+    RawPtr<HTMLAllCollection> all();
 
-    PassRefPtrWillBeRawPtr<HTMLCollection> windowNamedItems(const AtomicString& name);
-    PassRefPtrWillBeRawPtr<DocumentNameCollection> documentNamedItems(const AtomicString& name);
+    RawPtr<HTMLCollection> windowNamedItems(const AtomicString& name);
+    RawPtr<DocumentNameCollection> documentNamedItems(const AtomicString& name);
 
     bool isHTMLDocument() const { return m_documentClasses & HTMLDocumentClass; }
     bool isXHTMLDocument() const { return m_documentClasses & XHTMLDocumentClass; }
     bool isXMLDocument() const { return m_documentClasses & XMLDocumentClass; }
     bool isImageDocument() const { return m_documentClasses & ImageDocumentClass; }
     bool isSVGDocument() const { return m_documentClasses & SVGDocumentClass; }
     bool isPluginDocument() const { return m_documentClasses & PluginDocumentClass; }
     bool isMediaDocument() const { return m_documentClasses & MediaDocumentClass; }
 
     bool hasSVGRootNode() const;
@@ skipping 48 matching lines @@
     void setStateForNewFormElements(const Vector<String>&);
 
     FrameView* view() const; // can be null
     LocalFrame* frame() const { return m_frame; } // can be null
     FrameHost* frameHost() const; // can be null
     Page* page() const; // can be null
     Settings* settings() const; // can be null
 
     float devicePixelRatio() const;
 
-    PassRefPtrWillBeRawPtr<Range> createRange();
+    RawPtr<Range> createRange();
 
-    PassRefPtrWillBeRawPtr<NodeIterator> createNodeIterator(Node* root, unsigned whatToShow, PassRefPtrWillBeRawPtr<NodeFilter>);
-    PassRefPtrWillBeRawPtr<TreeWalker> createTreeWalker(Node* root, unsigned whatToShow, PassRefPtrWillBeRawPtr<NodeFilter>);
+    RawPtr<NodeIterator> createNodeIterator(Node* root, unsigned whatToShow, RawPtr<NodeFilter>);
+    RawPtr<TreeWalker> createTreeWalker(Node* root, unsigned whatToShow, RawPtr<NodeFilter>);
 
     // Special support for editing
-    PassRefPtrWillBeRawPtr<Text> createEditingTextNode(const String&);
+    RawPtr<Text> createEditingTextNode(const String&);
 
     void setupFontBuilder(ComputedStyle& documentStyle);
 
     bool needsLayoutTreeUpdate() const;
     // Update ComputedStyles and attach LayoutObjects if necessary, but don't
     // lay out.
     void updateLayoutTreeIfNeeded() { updateLayoutTree(NoChange); }
     // Same as updateLayoutTreeIfNeeded except ignoring pending stylesheets.
     void updateLayoutTreeIgnorePendingStylesheets();
     void updateLayoutTreeForNodeIfNeeded(Node*);
@@ skipping 34 matching lines @@
     // to get visually ordered hebrew and arabic pages right
     bool visuallyOrdered() const { return m_visuallyOrdered; }
 
     DocumentLoader* loader() const;
 
     // This is the DOM API document.open(). enteredDocument is the responsible
     // document of the entry settings object.
     void open(Document* enteredDocument, ExceptionState&);
     // This is used internally and does not handle exceptions.
     void open();
-    PassRefPtrWillBeRawPtr<DocumentParser> implicitOpen(ParserSynchronizationPolicy);
+    RawPtr<DocumentParser> implicitOpen(ParserSynchronizationPolicy);
 
     // This is the DOM API document.close()
     void close(ExceptionState&);
     // This is used internally and does not handle exceptions.
     void close();
     // implicitClose() actually does the work of closing the input stream.
     void implicitClose();
 
     bool dispatchBeforeUnloadEvent(ChromeClient&, bool isReload, bool& didAllowNavigation);
     void dispatchUnloadEvents();
@@ skipping 40 matching lines @@
     // Determines which base URL should be used given specified override.
     // If override is empty or is about:blank url and parent document exists
     // base URL of parent will be returned, passed base URL override otherwise.
     const KURL& baseURLForOverride(const KURL& baseURLOverride) const;
 
     String userAgent() const final;
     void disableEval(const String& errorMessage) final;
 
     CSSStyleSheet& elementSheet();
 
-    virtual PassRefPtrWillBeRawPtr<DocumentParser> createParser();
+    virtual RawPtr<DocumentParser> createParser();
     DocumentParser* parser() const { return m_parser.get(); }
     ScriptableDocumentParser* scriptableDocumentParser() const;
 
     bool printing() const { return m_printing; }
     void setPrinting(bool isPrinting) { m_printing = isPrinting; }
     bool wasPrinting() const { return m_wasPrinting; }
 
     bool paginatedForScreen() const { return m_paginatedForScreen; }
     void setPaginatedForScreen(bool p) { m_paginatedForScreen = p; }
 
@@ skipping 37 matching lines @@
     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const LayoutPoint&, const PlatformMouseEvent&);
 
     /* Newly proposed CSS3 mechanism for selecting alternate
        stylesheets using the DOM. May be subject to change as
        spec matures. - dwh
     */
     String preferredStylesheetSet() const;
     String selectedStylesheetSet() const;
     void setSelectedStylesheetSet(const String&);
 
-    bool setFocusedElement(PassRefPtrWillBeRawPtr<Element>, const FocusParams&);
+    bool setFocusedElement(RawPtr<Element>, const FocusParams&);
     void clearFocusedElement();
     Element* focusedElement() const { return m_focusedElement.get(); }
     UserActionElementSet& userActionElements()  { return m_userActionElements; }
     const UserActionElementSet& userActionElements() const { return m_userActionElements; }
     void setNeedsFocusedElementCheck();
     void setAutofocusElement(Element*);
     Element* autofocusElement() const { return m_autofocusElement.get(); }
 
-    void setActiveHoverElement(PassRefPtrWillBeRawPtr<Element>);
+    void setActiveHoverElement(RawPtr<Element>);
     Element* activeHoverElement() const { return m_activeHoverElement.get(); }
 
     Node* hoverNode() const { return m_hoverNode.get(); }
 
     void removeFocusedElementOfSubtree(Node*, bool amongChildrenOnly = false);
     void hoveredNodeDetached(Element&);
     void activeChainNodeDetached(Element&);
 
     void updateHoverActiveState(const HitTestRequest&, Element*);
 
@@ skipping 28 matching lines @@
 
     void didInsertText(Node*, unsigned offset, unsigned length);
     void didRemoveText(Node*, unsigned offset, unsigned length);
     void didMergeTextNodes(Text& oldNode, unsigned offset);
     void didSplitTextNode(Text& oldNode);
 
     void clearDOMWindow() { m_domWindow = nullptr; }
     LocalDOMWindow* domWindow() const { return m_domWindow; }
 
     // Helper functions for forwarding LocalDOMWindow event related tasks to the LocalDOMWindow if it exists.
-    void setWindowAttributeEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener>);
+    void setWindowAttributeEventListener(const AtomicString& eventType, RawPtr<EventListener>);
     EventListener* getWindowAttributeEventListener(const AtomicString& eventType);
 
     static void registerEventFactory(PassOwnPtr<EventFactoryBase>);
-    static PassRefPtrWillBeRawPtr<Event> createEvent(const String& eventType, ExceptionState&);
+    static RawPtr<Event> createEvent(const String& eventType, ExceptionState&);
 
     // keep track of what types of event listeners are registered, so we don't
     // dispatch events unnecessarily
     enum ListenerType {
         DOMSUBTREEMODIFIED_LISTENER          = 1,
         DOMNODEINSERTED_LISTENER             = 1 << 1,
         DOMNODEREMOVED_LISTENER              = 1 << 2,
         DOMNODEREMOVEDFROMDOCUMENT_LISTENER  = 1 << 3,
         DOMNODEINSERTEDINTODOCUMENT_LISTENER = 1 << 4,
         DOMCHARACTERDATAMODIFIED_LISTENER    = 1 << 5,
         ANIMATIONEND_LISTENER                = 1 << 6,
         ANIMATIONSTART_LISTENER              = 1 << 7,
         ANIMATIONITERATION_LISTENER          = 1 << 8,
         TRANSITIONEND_LISTENER               = 1 << 9,
         SCROLL_LISTENER                      = 1 << 10
         // 5 bits remaining
     };
 
     bool hasListenerType(ListenerType listenerType) const { return (m_listenerTypes & listenerType); }
     void addListenerTypeIfNeeded(const AtomicString& eventType);
 
     bool hasMutationObserversOfType(MutationObserver::MutationType type) const
     {
         return m_mutationObserverTypes & type;
     }
     bool hasMutationObservers() const { return m_mutationObserverTypes; }
     void addMutationObserverTypes(MutationObserverOptions types) { m_mutationObserverTypes |= types; }
 
-    WeakPtrWillBeRawPtr<Document> createWeakPtr();
+    RawPtr<Document> createWeakPtr();
 
     IntersectionObserverController* intersectionObserverController();
     IntersectionObserverController& ensureIntersectionObserverController();
     NodeIntersectionObserverData& ensureIntersectionObserverData();
 
     void updateViewportDescription();
     void processReferrerPolicy(const String& policy);
 
     // Returns the owning element in the parent document.
     // Returns nullptr if this is the top level document.
@@ skipping 53 matching lines @@
     static bool hasValidNamespaceForAttributes(const QualifiedName&);
 
     // "body element" as defined by HTML5 (https://html.spec.whatwg.org/multipage/dom.html#the-body-element-2).
     // That is, the first body or frameset child of the document element.
     HTMLElement* body() const;
 
     // "HTML body element" as defined by CSSOM View spec (http://dev.w3.org/csswg/cssom-view/#the-html-body-element).
     // That is, the first body child of the document element.
     HTMLBodyElement* firstBodyElement() const;
 
-    void setBody(PassRefPtrWillBeRawPtr<HTMLElement>, ExceptionState&);
+    void setBody(RawPtr<HTMLElement>, ExceptionState&);
 
     HTMLHeadElement* head() const;
 
     // Decide which element is to define the viewport's overflow policy. If |rootStyle| is set, use
     // that as the style for the root element, rather than obtaining it on our own. The reason for
     // this is that style may not have been associated with the elements yet - in which case it may
     // have been calculated on the fly (without associating it with the actual element) somewhere.
     Element* viewportDefiningElement(const ComputedStyle* rootStyle = nullptr) const;
 
     DocumentMarkerController& markers() const { return *m_markers; }
 
     bool execCommand(const String& command, bool showUI, const String& value, ExceptionState&);
     bool isRunningExecCommand() const { return m_isRunningExecCommand; }
     bool queryCommandEnabled(const String& command, ExceptionState&);
     bool queryCommandIndeterm(const String& command, ExceptionState&);
     bool queryCommandState(const String& command, ExceptionState&);
     bool queryCommandSupported(const String& command, ExceptionState&);
     String queryCommandValue(const String& command, ExceptionState&);
 
     KURL openSearchDescriptionURL();
 
     // designMode support
     bool inDesignMode() const { return m_designMode; }
     String designMode() const;
     void setDesignMode(const String&);
 
     Document* parentDocument() const;
     Document& topDocument() const;
-    WeakPtrWillBeRawPtr<Document> contextDocument();
+    RawPtr<Document> contextDocument();
 
     ScriptRunner* scriptRunner() { return m_scriptRunner.get(); }
 
     HTMLScriptElement* currentScript() const { return !m_currentScriptStack.isEmpty() ? m_currentScriptStack.last().get() : nullptr; }
-    void pushCurrentScript(PassRefPtrWillBeRawPtr<HTMLScriptElement>);
+    void pushCurrentScript(RawPtr<HTMLScriptElement>);
     void popCurrentScript();
 
     void setTransformSource(PassOwnPtr<TransformSource>);
     TransformSource* transformSource() const { return m_transformSource.get(); }
 
     void incDOMTreeVersion() { ASSERT(m_lifecycle.stateAllowsTreeMutations()); m_domTreeVersion = ++s_globalTreeVersion; }
     uint64_t domTreeVersion() const { return m_domTreeVersion; }
 
     uint64_t styleVersion() const { return m_styleVersion; }
 
@@ skipping 47 matching lines @@
     const Vector<AnnotatedRegionValue>& annotatedRegions() const;
     void setAnnotatedRegions(const Vector<AnnotatedRegionValue>&);
 
     void removeAllEventListeners() final;
 
     const SVGDocumentExtensions* svgExtensions();
     SVGDocumentExtensions& accessSVGExtensions();
 
     void initSecurityContext();
     void initSecurityContext(const DocumentInit&);
-    void initContentSecurityPolicy(PassRefPtrWillBeRawPtr<ContentSecurityPolicy> = nullptr);
+    void initContentSecurityPolicy(RawPtr<ContentSecurityPolicy> = nullptr);
 
     bool allowInlineEventHandlers(Node*, EventListener*, const String& contextURL, const WTF::OrdinalNumber& contextLine);
     bool allowExecutingScripts(Node*);
 
     void statePopped(PassRefPtr<SerializedScriptValue>);
 
     enum LoadEventProgress {
         LoadEventNotRun,
         LoadEventInProgress,
         LoadEventCompleted,
@@ skipping 14 matching lines @@
     bool containsPlugins() const { return m_containsPlugins; }
 
     bool isContextThread() const final;
     bool isJSExecutionForbidden() const final { return false; }
 
     bool containsValidityStyleRules() const { return m_containsValidityStyleRules; }
     void setContainsValidityStyleRules() { m_containsValidityStyleRules = true; }
 
     void enqueueResizeEvent();
     void enqueueScrollEventForNode(Node*);
-    void enqueueAnimationFrameEvent(PassRefPtrWillBeRawPtr<Event>);
+    void enqueueAnimationFrameEvent(RawPtr<Event>);
     // Only one event for a target/event type combination will be dispatched per frame.
-    void enqueueUniqueAnimationFrameEvent(PassRefPtrWillBeRawPtr<Event>);
-    void enqueueMediaQueryChangeListeners(WillBeHeapVector<RefPtrWillBeMember<MediaQueryListListener>>&);
+    void enqueueUniqueAnimationFrameEvent(RawPtr<Event>);
+    void enqueueMediaQueryChangeListeners(HeapVector<Member<MediaQueryListListener>>&);
 
     void dispatchEventsForPrinting();
 
     bool hasFullscreenSupplement() const { return m_hasFullscreenSupplement; }
     void setHasFullscreenSupplement() { m_hasFullscreenSupplement = true; }
 
     void exitPointerLock();
     Element* pointerLockElement() const;
 
     // Used to allow element that loads data without going through a FrameLoader to delay the 'load' event.
     void incrementLoadEventDelayCount() { ++m_loadEventDelayCount; }
     void decrementLoadEventDelayCount();
     void checkLoadEventSoon();
     bool isDelayingLoadEvent();
     void loadPluginsSoon();
 
-    PassRefPtrWillBeRawPtr<Touch> createTouch(DOMWindow*, EventTarget*, int identifier, double pageX, double pageY, double screenX, double screenY, double radiusX, double radiusY, float rotationAngle, float force) const;
-    PassRefPtrWillBeRawPtr<TouchList> createTouchList(WillBeHeapVector<RefPtrWillBeMember<Touch>>&) const;
+    RawPtr<Touch> createTouch(DOMWindow*, EventTarget*, int identifier, double pageX, double pageY, double screenX, double screenY, double radiusX, double radiusY, float rotationAngle, float force) const;
+    RawPtr<TouchList> createTouchList(HeapVector<Member<Touch>>&) const;
 
     const DocumentTiming& timing() const { return m_documentTiming; }
 
     int requestAnimationFrame(FrameRequestCallback*);
     void cancelAnimationFrame(int id);
     void serviceScriptedAnimations(double monotonicAnimationStartTime);
 
     int requestIdleCallback(IdleRequestCallback*, const IdleRequestOptions&);
     void cancelIdleCallback(int id);
 
     EventTarget* errorEventTarget() final;
     void logExceptionToConsole(const String& errorMessage, int scriptId, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtr<ScriptCallStack>) final;
 
     void initDNSPrefetch();
 
     bool isInDocumentWrite() { return m_writeRecursionDepth > 0; }
 
     TextAutosizer* textAutosizer();
 
-    PassRefPtrWillBeRawPtr<Element> createElement(const AtomicString& localName, const AtomicString& typeExtension, ExceptionState&);
-    PassRefPtrWillBeRawPtr<Element> createElementNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& typeExtension, ExceptionState&);
+    RawPtr<Element> createElement(const AtomicString& localName, const AtomicString& typeExtension, ExceptionState&);
+    RawPtr<Element> createElementNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& typeExtension, ExceptionState&);
     ScriptValue registerElement(ScriptState*, const AtomicString& name, const ElementRegistrationOptions&, ExceptionState&, CustomElement::NameSet validNames = CustomElement::StandardNames);
     CustomElementRegistrationContext* registrationContext() { return m_registrationContext.get(); }
     CustomElementMicrotaskRunQueue* customElementMicrotaskRunQueue();
 
     void setImportsController(HTMLImportsController*);
     HTMLImportsController* importsController() const { return m_importsController; }
     HTMLImportLoader* importLoader() const;
 
     bool haveImportsLoaded() const;
     void didLoadAllImports();
@@ skipping 18 matching lines @@
 
     // Return a Locale for the default locale if the argument is null or empty.
     Locale& getCachedLocale(const AtomicString& locale = nullAtom);
 
     AnimationClock& animationClock();
     AnimationTimeline& timeline() const { return *m_timeline; }
     CompositorPendingAnimations& compositorPendingAnimations() { return m_compositorPendingAnimations; }
 
     void addToTopLayer(Element*, const Element* before = nullptr);
     void removeFromTopLayer(Element*);
-    const WillBeHeapVector<RefPtrWillBeMember<Element>>& topLayerElements() const { return m_topLayerElements; }
+    const HeapVector<Member<Element>>& topLayerElements() const { return m_topLayerElements; }
     HTMLDialogElement* activeModalDialog() const;
 
     // A non-null m_templateDocumentHost implies that |this| was created by ensureTemplateDocument().
     bool isTemplateDocument() const { return !!m_templateDocumentHost; }
     Document& ensureTemplateDocument();
     Document* templateDocumentHost() { return m_templateDocumentHost; }
 
     // TODO(thestig): Rename these and related functions, since we can call them
     // for labels and input fields outside of forms as well.
     void didAssociateFormControl(Element*);
     void removeFormAssociation(Element*);
 
-    void addConsoleMessage(PassRefPtrWillBeRawPtr<ConsoleMessage>) final;
+    void addConsoleMessage(RawPtr<ConsoleMessage>) final;
 
     LocalDOMWindow* executingWindow() final;
     LocalFrame* executingFrame();
 
     DocumentLifecycle& lifecycle() { return m_lifecycle; }
     bool isActive() const { return m_lifecycle.isActive(); }
     bool isDetached() const { return m_lifecycle.state() >= DocumentLifecycle::Stopping; }
     bool isStopped() const { return m_lifecycle.state() == DocumentLifecycle::Stopped; }
     bool isDisposed() const { return m_lifecycle.state() == DocumentLifecycle::Disposed; }
 
@@ skipping 44 matching lines @@
     static bool threadedParsingEnabledForTesting();
 
     void incrementNodeCount() { m_nodeCount++; }
     void decrementNodeCount()
     {
         ASSERT(m_nodeCount > 0);
         m_nodeCount--;
     }
     int nodeCount() const { return m_nodeCount; }
 
-    using WeakDocumentSet = WillBeHeapHashSet<RawPtrWillBeWeakMember<Document>>;
+    using WeakDocumentSet = HeapHashSet<WeakMember<Document>>;
     static WeakDocumentSet& liveDocumentSet();
 
     WebTaskRunner* loadingTaskRunner() const;
     WebTaskRunner* timerTaskRunner() const;
 
     void enforceStrictMixedContentChecking();
 
 protected:
     Document(const DocumentInit&, DocumentClassFlags = DefaultDocumentClass);
 
     void didUpdateSecurityOrigin() final;
 
     void clearXMLVersion() { m_xmlVersion = String(); }
 
 #if !ENABLE(OILPAN)
     void dispose() override;
 #endif
 
-    virtual PassRefPtrWillBeRawPtr<Document> cloneDocumentWithoutChildren();
+    virtual RawPtr<Document> cloneDocumentWithoutChildren();
 
-    bool importContainerNodeChildren(ContainerNode* oldContainerNode, PassRefPtrWillBeRawPtr<ContainerNode> newContainerNode, ExceptionState&);
+    bool importContainerNodeChildren(ContainerNode* oldContainerNode, RawPtr<ContainerNode> newContainerNode, ExceptionState&);
     void lockCompatibilityMode() { m_compatibilityModeLocked = true; }
     ParserSynchronizationPolicy parserSynchronizationPolicy() const { return m_parserSyncPolicy; }
 
 private:
     friend class IgnoreDestructiveWriteCountIncrementer;
     friend class NthIndexCache;
 
     bool isDocumentFragment() const = delete; // This will catch anyone doing an unnecessary check.
     bool isDocumentNode() const = delete; // This will catch anyone doing an unnecessary check.
     bool isElementNode() const = delete; // This will catch anyone doing an unnecessary check.
@@ skipping 24 matching lines @@
 
     void detachParser();
 
     bool isDocument() const final { return true; }
 
     void childrenChanged(const ChildrenChange&) override;
 
     String nodeName() const final;
     NodeType nodeType() const final;
     bool childTypeAllowed(NodeType) const final;
-    PassRefPtrWillBeRawPtr<Node> cloneNode(bool deep) final;
+    RawPtr<Node> cloneNode(bool deep) final;
     void cloneDataFromDocument(const Document&);
     bool isSecureContextImpl(String* errorMessage, const SecureContextCheck priviligeContextCheck) const;
 
 #if !ENABLE(OILPAN)
     void refExecutionContext() final { ref(); }
     void derefExecutionContext() final { deref(); }
 #endif
 
     const KURL& virtualURL() const final; // Same as url(), but needed for ExecutionContext to implement it without a performance loss for direct calls.
     KURL virtualCompleteURL(const String&) const final; // Same as completeURL() for the same reason as above.
@@ skipping 12 matching lines @@
     void addListenerType(ListenerType listenerType) { m_listenerTypes |= listenerType; }
     void addMutationEventListenerTypeIfEnabled(ListenerType);
 
     void didAssociateFormControlsTimerFired(Timer<Document>*);
 
     void clearFocusedElementSoon();
     void clearFocusedElementTimerFired(Timer<Document>*);
 
     bool haveStylesheetsLoaded() const;
 
-    void setHoverNode(PassRefPtrWillBeRawPtr<Node>);
+    void setHoverNode(RawPtr<Node>);
 
     using EventFactorySet = HashSet<OwnPtr<EventFactoryBase>>;
     static EventFactorySet& eventFactories();
 
     void setNthIndexCache(NthIndexCache* nthIndexCache) { ASSERT(!m_nthIndexCache || !nthIndexCache); m_nthIndexCache = nthIndexCache; }
 
     const OriginAccessEntry& accessEntryFromURL();
 
     DocumentLifecycle m_lifecycle;
 
     bool m_hasNodesWithPlaceholderStyle;
     bool m_evaluateMediaQueriesOnStyleRecalc;
 
     // If we do ignore the pending stylesheet count, then we need to add a boolean
     // to track that this happened so that we can do a full repaint when the stylesheets
     // do eventually load.
     PendingSheetLayout m_pendingSheetLayout;
 
-    RawPtrWillBeMember<LocalFrame> m_frame;
-    RawPtrWillBeMember<LocalDOMWindow> m_domWindow;
+    Member<LocalFrame> m_frame;
+    Member<LocalDOMWindow> m_domWindow;
     // FIXME: oilpan: when we get rid of the transition types change the
     // HTMLImportsController to not be a DocumentSupplement since it is
     // redundant with oilpan.
-    RawPtrWillBeMember<HTMLImportsController> m_importsController;
+    Member<HTMLImportsController> m_importsController;
 
-    PersistentWillBeMember<ResourceFetcher> m_fetcher;
-    RefPtrWillBeMember<DocumentParser> m_parser;
+    Member<ResourceFetcher> m_fetcher;
+    Member<DocumentParser> m_parser;
     unsigned m_activeParserCount;
-    RefPtrWillBeMember<ContextFeatures> m_contextFeatures;
+    Member<ContextFeatures> m_contextFeatures;
 
     bool m_wellFormed;
 
     // Document URLs.
     KURL m_url; // Document.URL: The URL from which this document was retrieved.
     KURL m_baseURL; // Node.baseURI: The URL to use when resolving relative URLs.
     KURL m_baseURLOverride; // An alternative base URL that takes precedence over m_baseURL (but not m_baseElementURL).
     KURL m_baseElementURL; // The URL set by the <base> element.
     KURL m_cookieURL; // The URL to use for cookie access.
     OwnPtr<OriginAccessEntry> m_accessEntryFromURL;
 
     AtomicString m_baseTarget;
 
     // Mime-type of the document in case it was cloned or created by XHR.
     AtomicString m_mimeType;
 
-    RefPtrWillBeMember<DocumentType> m_docType;
-    OwnPtrWillBeMember<DOMImplementation> m_implementation;
+    Member<DocumentType> m_docType;
+    Member<DOMImplementation> m_implementation;
 
-    RefPtrWillBeMember<CSSStyleSheet> m_elemSheet;
+    Member<CSSStyleSheet> m_elemSheet;
 
     bool m_printing;
     bool m_wasPrinting;
     bool m_paginatedForScreen;
 
     CompatibilityMode m_compatibilityMode;
     bool m_compatibilityModeLocked; // This is cheaper than making setCompatibilityMode virtual.
 
     OwnPtr<CancellableTaskFactory> m_executeScriptsWaitingForResourcesTask;
 
     bool m_hasAutofocused;
     Timer<Document> m_clearFocusedElementTimer;
-    RefPtrWillBeMember<Element> m_autofocusElement;
-    RefPtrWillBeMember<Element> m_focusedElement;
-    RefPtrWillBeMember<Node> m_hoverNode;
-    RefPtrWillBeMember<Element> m_activeHoverElement;
-    RefPtrWillBeMember<Element> m_documentElement;
+    Member<Element> m_autofocusElement;
+    Member<Element> m_focusedElement;
+    Member<Node> m_hoverNode;
+    Member<Element> m_activeHoverElement;
+    Member<Element> m_documentElement;
     UserActionElementSet m_userActionElements;
 
     uint64_t m_domTreeVersion;
     static uint64_t s_globalTreeVersion;
 
     uint64_t m_styleVersion;
 
-    WillBeHeapHashSet<RawPtrWillBeWeakMember<NodeIterator>> m_nodeIterators;
-    using AttachedRangeSet = WillBeHeapHashSet<RawPtrWillBeWeakMember<Range>>;
+    HeapHashSet<WeakMember<NodeIterator>> m_nodeIterators;
+    using AttachedRangeSet = HeapHashSet<WeakMember<Range>>;
     AttachedRangeSet m_ranges;
 
     unsigned short m_listenerTypes;
 
     MutationObserverOptions m_mutationObserverTypes;
 
-    OwnPtrWillBeMember<StyleEngine> m_styleEngine;
-    RefPtrWillBeMember<StyleSheetList> m_styleSheetList;
+    Member<StyleEngine> m_styleEngine;
+    Member<StyleSheetList> m_styleSheetList;
 
-    OwnPtrWillBeMember<FormController> m_formController;
+    Member<FormController> m_formController;
 
     TextLinkColors m_textLinkColors;
-    const OwnPtrWillBeMember<VisitedLinkState> m_visitedLinkState;
+    const Member<VisitedLinkState> m_visitedLinkState;
 
     bool m_visuallyOrdered;
     ReadyState m_readyState;
     ParsingState m_parsingState;
 
     bool m_gotoAnchorNeededAfterStylesheetsLoad;
     bool m_isDNSPrefetchEnabled;
     bool m_haveExplicitlyDisabledDNSPrefetch;
     bool m_containsValidityStyleRules;
     bool m_containsPlugins;
     SelectionBehaviorOnFocus m_updateFocusAppearanceSelectionBahavior;
 
     // http://www.whatwg.org/specs/web-apps/current-work/#ignore-destructive-writes-counter
     unsigned m_ignoreDestructiveWriteCount;
 
     String m_title;
     String m_rawTitle;
-    RefPtrWillBeMember<Element> m_titleElement;
+    Member<Element> m_titleElement;
 
-    PersistentWillBeMember<AXObjectCache> m_axObjectCache;
-    OwnPtrWillBeMember<DocumentMarkerController> m_markers;
+    Member<AXObjectCache> m_axObjectCache;
+    Member<DocumentMarkerController> m_markers;
 
     Timer<Document> m_updateFocusAppearanceTimer;
 
-    RawPtrWillBeMember<Element> m_cssTarget;
+    Member<Element> m_cssTarget;
 
     LoadEventProgress m_loadEventProgress;
 
     double m_startTime;
 
-    OwnPtrWillBeMember<ScriptRunner> m_scriptRunner;
+    Member<ScriptRunner> m_scriptRunner;
 
-    WillBeHeapVector<RefPtrWillBeMember<HTMLScriptElement>> m_currentScriptStack;
+    HeapVector<Member<HTMLScriptElement>> m_currentScriptStack;
 
     OwnPtr<TransformSource> m_transformSource;
 
     String m_xmlEncoding;
     String m_xmlVersion;
     unsigned m_xmlStandalone : 2;
     unsigned m_hasXMLDeclaration : 1;
 
     AtomicString m_contentLanguage;
 
     DocumentEncodingData m_encodingData;
 
     bool m_designMode;
     bool m_isRunningExecCommand;
 
-    WillBeHeapHashSet<RawPtrWillBeWeakMember<const LiveNodeListBase>> m_listsInvalidatedAtDocument;
+    HeapHashSet<WeakMember<const LiveNodeListBase>> m_listsInvalidatedAtDocument;
 #if ENABLE(OILPAN)
     // Oilpan keeps track of all registered NodeLists.
     //
     // FIXME: Oilpan: improve - only need to know if a NodeList
     // is currently alive or not for the different types.
     HeapHashSet<WeakMember<const LiveNodeListBase>> m_nodeLists[numNodeListInvalidationTypes];
 #else
     unsigned m_nodeListCounts[numNodeListInvalidationTypes];
 #endif
 
-    OwnPtrWillBeMember<SVGDocumentExtensions> m_svgExtensions;
+    Member<SVGDocumentExtensions> m_svgExtensions;
 
     Vector<AnnotatedRegionValue> m_annotatedRegions;
     bool m_hasAnnotatedRegions;
     bool m_annotatedRegionsDirty;
 
     OwnPtr<SelectorQueryCache> m_selectorQueryCache;
 
     // It is safe to keep a raw, untraced pointer to this stack-allocated
     // cache object: it is set upon the cache object being allocated on
     // the stack and cleared upon leaving its allocated scope. Hence it
     // is acceptable not to trace it -- should a conservative GC occur,
     // the cache object's references will be traced by a stack walk.
     GC_PLUGIN_IGNORE("461878")
     NthIndexCache* m_nthIndexCache = nullptr;
 
     bool m_useSecureKeyboardEntryWhenActive;
 
     DocumentClassFlags m_documentClasses;
 
     bool m_isViewSource;
     bool m_sawElementsInKnownNamespaces;
     bool m_isSrcdocDocument;
     bool m_isMobileDocument;
 
     LayoutView* m_layoutView;
 
 #if !ENABLE(OILPAN)
     WeakPtrFactory<Document> m_weakFactory;
 #endif
-    WeakPtrWillBeWeakMember<Document> m_contextDocument;
+    WeakMember<Document> m_contextDocument;
 
     bool m_hasFullscreenSupplement; // For early return in Fullscreen::fromIfExists()
 
-    WillBeHeapVector<RefPtrWillBeMember<Element>> m_topLayerElements;
+    HeapVector<Member<Element>> m_topLayerElements;
 
     int m_loadEventDelayCount;
     Timer<Document> m_loadEventDelayTimer;
     Timer<Document> m_pluginLoadingTimer;
 
     ViewportDescription m_viewportDescription;
     ViewportDescription m_legacyViewportDescription;
     Length m_viewportDefaultMinWidth;
 
     ReferrerPolicy m_referrerPolicy;
 
     DocumentTiming m_documentTiming;
-    RefPtrWillBeMember<MediaQueryMatcher> m_mediaQueryMatcher;
+    Member<MediaQueryMatcher> m_mediaQueryMatcher;
     bool m_writeRecursionIsTooDeep;
     unsigned m_writeRecursionDepth;
 
-    RefPtrWillBeMember<ScriptedAnimationController> m_scriptedAnimationController;
-    RefPtrWillBeMember<ScriptedIdleTaskController> m_scriptedIdleTaskController;
-    OwnPtrWillBeMember<MainThreadTaskRunner> m_taskRunner;
-    OwnPtrWillBeMember<TextAutosizer> m_textAutosizer;
+    Member<ScriptedAnimationController> m_scriptedAnimationController;
+    Member<ScriptedIdleTaskController> m_scriptedIdleTaskController;
+    Member<MainThreadTaskRunner> m_taskRunner;
+    Member<TextAutosizer> m_textAutosizer;
 
-    RefPtrWillBeMember<CustomElementRegistrationContext> m_registrationContext;
-    RefPtrWillBeMember<CustomElementMicrotaskRunQueue> m_customElementMicrotaskRunQueue;
+    Member<CustomElementRegistrationContext> m_registrationContext;
+    Member<CustomElementMicrotaskRunQueue> m_customElementMicrotaskRunQueue;
 
     void elementDataCacheClearTimerFired(Timer<Document>*);
     Timer<Document> m_elementDataCacheClearTimer;
 
-    OwnPtrWillBeMember<ElementDataCache> m_elementDataCache;
+    Member<ElementDataCache> m_elementDataCache;
 
     using LocaleIdentifierToLocaleMap = HashMap<AtomicString, OwnPtr<Locale>>;
     LocaleIdentifierToLocaleMap m_localeCache;
 
-    PersistentWillBeMember<AnimationTimeline> m_timeline;
+    Member<AnimationTimeline> m_timeline;
     CompositorPendingAnimations m_compositorPendingAnimations;
 
-    RefPtrWillBeMember<Document> m_templateDocument;
+    Member<Document> m_templateDocument;
     // With Oilpan the templateDocument and the templateDocumentHost
     // live and die together. Without Oilpan, the templateDocumentHost
     // is a manually managed backpointer from m_templateDocument.
-    RawPtrWillBeMember<Document> m_templateDocumentHost;
+    Member<Document> m_templateDocumentHost;
 
     Timer<Document> m_didAssociateFormControlsTimer;
-    WillBeHeapHashSet<RefPtrWillBeMember<Element>> m_associatedFormControls;
+    HeapHashSet<Member<Element>> m_associatedFormControls;
 
-    WillBeHeapHashSet<RawPtrWillBeMember<SVGUseElement>> m_useElementsNeedingUpdate;
-    WillBeHeapHashSet<RawPtrWillBeMember<Element>> m_layerUpdateSVGFilterElements;
+    HeapHashSet<Member<SVGUseElement>> m_useElementsNeedingUpdate;
+    HeapHashSet<Member<Element>> m_layerUpdateSVGFilterElements;
 
     DOMTimerCoordinator m_timers;
 
     bool m_hasViewportUnits;
 
-    using DocumentVisibilityObserverSet = WillBeHeapHashSet<RawPtrWillBeWeakMember<DocumentVisibilityObserver>>;
+    using DocumentVisibilityObserverSet = HeapHashSet<WeakMember<DocumentVisibilityObserver>>;
     DocumentVisibilityObserverSet m_visibilityObservers;
 
     ParserSynchronizationPolicy m_parserSyncPolicy;
 
     OriginsUsingFeatures::Value m_originsUsingFeaturesValue;
 
     ClientHintsPreferences m_clientHintsPreferences;
 
-    PersistentWillBeMember<CanvasFontCache> m_canvasFontCache;
+    Member<CanvasFontCache> m_canvasFontCache;
 
-    PersistentWillBeMember<IntersectionObserverController> m_intersectionObserverController;
-    PersistentWillBeMember<NodeIntersectionObserverData> m_intersectionObserverData;
+    Member<IntersectionObserverController> m_intersectionObserverController;
+    Member<NodeIntersectionObserverData> m_intersectionObserverData;
 
     int m_nodeCount;
 };
 
-extern template class CORE_EXTERN_TEMPLATE_EXPORT WillBeHeapSupplement<Document>;
+extern template class CORE_EXTERN_TEMPLATE_EXPORT HeapSupplement<Document>;
 
 inline bool Document::shouldOverrideLegacyDescription(ViewportDescription::Type origin)
 {
     // The different (legacy) meta tags have different priorities based on the type
     // regardless of which order they appear in the DOM. The priority is given by the
     // ViewportDescription::Type enum.
     return origin >= m_legacyViewportDescription.type;
 }
 
 inline void Document::scheduleLayoutTreeUpdateIfNeeded()
@@ skipping 26 matching lines @@
 DEFINE_TYPE_CASTS(TreeScope, Document, document, true, true);
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 CORE_EXPORT void showLiveDocumentInstances();
 #endif
 
 #endif // Document_h