Oilpan: Remove most WillBe types from the code base

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

 /*
  * 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, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 343 matching lines @@
         *errorMessage = origin->isPotentiallyTrustworthyErrorMessage();
     return false;
 }
 
 uint64_t Document::s_globalTreeVersion = 0;
 
 static bool s_threadedParsingEnabledForTesting = true;
 
 Document::WeakDocumentSet& Document::liveDocumentSet()
 {
-    DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<WeakDocumentSet>, set, (adoptPtrWillBeNoop(new WeakDocumentSet())));
+    DEFINE_STATIC_LOCAL(Persistent<WeakDocumentSet>, set, (new WeakDocumentSet()));
     return *set;
 }
 
 // This class doesn't work with non-Document ExecutionContext.
 class AutofocusTask final : public ExecutionContextTask {
 public:
     static PassOwnPtr<AutofocusTask> create()
     {
         return adoptPtr(new AutofocusTask());
     }
     ~AutofocusTask() override { }
 
 private:
     AutofocusTask() { }
     void performTask(ExecutionContext* context) override
     {
         Document* document = toDocument(context);
-        if (RefPtrWillBeRawPtr<Element> element = document->autofocusElement()) {
+        if (RawPtr<Element> element = document->autofocusElement()) {
             document->setAutofocusElement(0);
             element->focus();
         }
     }
 };
 
 Document::Document(const DocumentInit& initializer, DocumentClassFlags documentClasses)
     : ContainerNode(0, CreateDocument)
     , TreeScope(*this)
     , m_hasNodesWithPlaceholderStyle(false)
@@ skipping 259 matching lines @@
         return;
     m_compatibilityMode = mode;
     selectorQueryCache().invalidate();
 }
 
 String Document::compatMode() const
 {
     return inQuirksMode() ? "BackCompat" : "CSS1Compat";
 }
 
-void Document::setDoctype(PassRefPtrWillBeRawPtr<DocumentType> docType)
+void Document::setDoctype(RawPtr<DocumentType> docType)
 {
     // This should never be called more than once.
     ASSERT(!m_docType || !docType);
     m_docType = docType;
     if (m_docType) {
         this->adoptIfNeeded(*m_docType);
         if (m_docType->publicId().startsWith("-//wapforum//dtd xhtml mobile 1.", TextCaseInsensitive))
             m_isMobileDocument = true;
     }
     // Doctype affects the interpretation of the stylesheets.
@@ skipping 24 matching lines @@
 {
     ContainerNode::childrenChanged(change);
     m_documentElement = ElementTraversal::firstWithin(*this);
 }
 
 AtomicString Document::convertLocalName(const AtomicString& name)
 {
     return isHTMLDocument() ? name.lower() : name;
 }
 
-PassRefPtrWillBeRawPtr<Element> Document::createElement(const AtomicString& name, ExceptionState& exceptionState)
+RawPtr<Element> Document::createElement(const AtomicString& name, ExceptionState& exceptionState)
 {
     if (!isValidName(name)) {
         exceptionState.throwDOMException(InvalidCharacterError, "The tag name provided ('" + name + "') is not a valid name.");
         return nullptr;
     }
 
     if (isXHTMLDocument() || isHTMLDocument())
         return HTMLElementFactory::createHTMLElement(convertLocalName(name), *this, 0, false);
 
     return Element::create(QualifiedName(nullAtom, name, nullAtom), this);
 }
 
-PassRefPtrWillBeRawPtr<Element> Document::createElement(const AtomicString& localName, const AtomicString& typeExtension, ExceptionState& exceptionState)
+RawPtr<Element> Document::createElement(const AtomicString& localName, const AtomicString& typeExtension, ExceptionState& exceptionState)
 {
     if (!isValidName(localName)) {
         exceptionState.throwDOMException(InvalidCharacterError, "The tag name provided ('" + localName + "') is not a valid name.");
         return nullptr;
     }
 
-    RefPtrWillBeRawPtr<Element> element;
+    RawPtr<Element> element;
 
     if (CustomElement::isValidName(localName) && registrationContext()) {
         element = registrationContext()->createCustomTagElement(*this, QualifiedName(nullAtom, convertLocalName(localName), xhtmlNamespaceURI));
     } else {
         element = createElement(localName, exceptionState);
         if (exceptionState.hadException())
             return nullptr;
     }
 
     if (!typeExtension.isEmpty())
@@ skipping 10 matching lines @@
 
     QualifiedName qName(prefix, localName, namespaceURI);
     if (!Document::hasValidNamespaceForElements(qName)) {
         exceptionState.throwDOMException(NamespaceError, "The namespace URI provided ('" + namespaceURI + "') is not valid for the qualified name provided ('" + qualifiedName + "').");
         return QualifiedName::null();
     }
 
     return qName;
 }
 
-PassRefPtrWillBeRawPtr<Element> Document::createElementNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionState& exceptionState)
+RawPtr<Element> Document::createElementNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionState& exceptionState)
 {
     QualifiedName qName(createQualifiedName(namespaceURI, qualifiedName, exceptionState));
     if (qName == QualifiedName::null())
         return nullptr;
 
     return createElement(qName, false);
 }
 
-PassRefPtrWillBeRawPtr<Element> Document::createElementNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& typeExtension, ExceptionState& exceptionState)
+RawPtr<Element> Document::createElementNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& typeExtension, ExceptionState& exceptionState)
 {
     QualifiedName qName(createQualifiedName(namespaceURI, qualifiedName, exceptionState));
     if (qName == QualifiedName::null())
         return nullptr;
 
-    RefPtrWillBeRawPtr<Element> element;
+    RawPtr<Element> element;
     if (CustomElement::isValidName(qName.localName()) && registrationContext())
         element = registrationContext()->createCustomTagElement(*this, qName);
     else
         element = createElement(qName, false);
 
     if (!typeExtension.isEmpty())
         CustomElementRegistrationContext::setIsAttributeAndTypeExtension(element.get(), typeExtension);
 
     return element.release();
 }
@@ skipping 51 matching lines @@
 }
 
 LocalFrame* Document::executingFrame()
 {
     LocalDOMWindow* window = executingWindow();
     if (!window)
         return 0;
     return window->frame();
 }
 
-PassRefPtrWillBeRawPtr<DocumentFragment> Document::createDocumentFragment()
+RawPtr<DocumentFragment> Document::createDocumentFragment()
 {
     return DocumentFragment::create(*this);
 }
 
-PassRefPtrWillBeRawPtr<Text> Document::createTextNode(const String& data)
+RawPtr<Text> Document::createTextNode(const String& data)
 {
     return Text::create(*this, data);
 }
 
-PassRefPtrWillBeRawPtr<Comment> Document::createComment(const String& data)
+RawPtr<Comment> Document::createComment(const String& data)
 {
     return Comment::create(*this, data);
 }
 
-PassRefPtrWillBeRawPtr<CDATASection> Document::createCDATASection(const String& data, ExceptionState& exceptionState)
+RawPtr<CDATASection> Document::createCDATASection(const String& data, ExceptionState& exceptionState)
 {
     if (isHTMLDocument()) {
         exceptionState.throwDOMException(NotSupportedError, "This operation is not supported for HTML documents.");
         return nullptr;
     }
     if (data.contains("]]>")) {
         exceptionState.throwDOMException(InvalidCharacterError, "String cannot contain ']]>' since that is the end delimiter of a CData section.");
         return nullptr;
     }
     return CDATASection::create(*this, data);
 }
 
-PassRefPtrWillBeRawPtr<ProcessingInstruction> Document::createProcessingInstruction(const String& target, const String& data, ExceptionState& exceptionState)
+RawPtr<ProcessingInstruction> Document::createProcessingInstruction(const String& target, const String& data, ExceptionState& exceptionState)
 {
     if (!isValidName(target)) {
         exceptionState.throwDOMException(InvalidCharacterError, "The target provided ('" + target + "') is not a valid name.");
         return nullptr;
     }
     if (data.contains("?>")) {
         exceptionState.throwDOMException(InvalidCharacterError, "The data provided ('" + data + "') contains '?>'.");
         return nullptr;
     }
     return ProcessingInstruction::create(*this, target, data);
 }
 
-PassRefPtrWillBeRawPtr<Text> Document::createEditingTextNode(const String& text)
+RawPtr<Text> Document::createEditingTextNode(const String& text)
 {
     return Text::createEditingText(*this, text);
 }
 
-bool Document::importContainerNodeChildren(ContainerNode* oldContainerNode, PassRefPtrWillBeRawPtr<ContainerNode> newContainerNode, ExceptionState& exceptionState)
+bool Document::importContainerNodeChildren(ContainerNode* oldContainerNode, RawPtr<ContainerNode> newContainerNode, ExceptionState& exceptionState)
 {
     for (Node& oldChild : NodeTraversal::childrenOf(*oldContainerNode)) {
-        RefPtrWillBeRawPtr<Node> newChild = importNode(&oldChild, true, exceptionState);
+        RawPtr<Node> newChild = importNode(&oldChild, true, exceptionState);
         if (exceptionState.hadException())
             return false;
         newContainerNode->appendChild(newChild.release(), exceptionState);
         if (exceptionState.hadException())
             return false;
     }
 
     return true;
 }
 
-PassRefPtrWillBeRawPtr<Node> Document::importNode(Node* importedNode, bool deep, ExceptionState& exceptionState)
+RawPtr<Node> Document::importNode(Node* importedNode, bool deep, ExceptionState& exceptionState)
 {
     switch (importedNode->getNodeType()) {
     case TEXT_NODE:
         return createTextNode(importedNode->nodeValue());
     case CDATA_SECTION_NODE:
         return CDATASection::create(*this, importedNode->nodeValue());
     case PROCESSING_INSTRUCTION_NODE:
         return createProcessingInstruction(importedNode->nodeName(), importedNode->nodeValue(), exceptionState);
     case COMMENT_NODE:
         return createComment(importedNode->nodeValue());
     case DOCUMENT_TYPE_NODE: {
         DocumentType* doctype = toDocumentType(importedNode);
         return DocumentType::create(this, doctype->name(), doctype->publicId(), doctype->systemId());
     }
     case ELEMENT_NODE: {
         Element* oldElement = toElement(importedNode);
         // FIXME: The following check might be unnecessary. Is it possible that
         // oldElement has mismatched prefix/namespace?
         if (!hasValidNamespaceForElements(oldElement->tagQName())) {
             exceptionState.throwDOMException(NamespaceError, "The imported node has an invalid namespace.");
             return nullptr;
         }
-        RefPtrWillBeRawPtr<Element> newElement = createElement(oldElement->tagQName(), false);
+        RawPtr<Element> newElement = createElement(oldElement->tagQName(), false);
 
         newElement->cloneDataFromElement(*oldElement);
 
         if (deep) {
             if (!importContainerNodeChildren(oldElement, newElement, exceptionState))
                 return nullptr;
             if (isHTMLTemplateElement(*oldElement)
                 && !ensureTemplateDocument().importContainerNodeChildren(
                     toHTMLTemplateElement(oldElement)->content(),
                     toHTMLTemplateElement(newElement)->content(), exceptionState))
                 return nullptr;
         }
 
         return newElement.release();
     }
     case ATTRIBUTE_NODE:
         return Attr::create(*this, QualifiedName(nullAtom, AtomicString(toAttr(importedNode)->name()), nullAtom), toAttr(importedNode)->value());
     case DOCUMENT_FRAGMENT_NODE: {
         if (importedNode->isShadowRoot()) {
             // ShadowRoot nodes should not be explicitly importable.
             // Either they are imported along with their host node, or created implicitly.
             exceptionState.throwDOMException(NotSupportedError, "The node provided is a shadow root, which may not be imported.");
             return nullptr;
         }
         DocumentFragment* oldFragment = toDocumentFragment(importedNode);
-        RefPtrWillBeRawPtr<DocumentFragment> newFragment = createDocumentFragment();
+        RawPtr<DocumentFragment> newFragment = createDocumentFragment();
         if (deep && !importContainerNodeChildren(oldFragment, newFragment, exceptionState))
             return nullptr;
 
         return newFragment.release();
     }
     case DOCUMENT_NODE:
         exceptionState.throwDOMException(NotSupportedError, "The node provided is a document, which may not be imported.");
         return nullptr;
     }
 
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<Node> Document::adoptNode(PassRefPtrWillBeRawPtr<Node> source, ExceptionState& exceptionState)
+RawPtr<Node> Document::adoptNode(RawPtr<Node> source, ExceptionState& exceptionState)
 {
     EventQueueScope scope;
 
     switch (source->getNodeType()) {
     case DOCUMENT_NODE:
         exceptionState.throwDOMException(NotSupportedError, "The node provided is of type '" + source->nodeName() + "', which may not be adopted.");
         return nullptr;
     case ATTRIBUTE_NODE: {
         Attr* attr = toAttr(source.get());
-        if (RefPtrWillBeRawPtr<Element> ownerElement = attr->ownerElement())
+        if (RawPtr<Element> ownerElement = attr->ownerElement())
             ownerElement->removeAttributeNode(attr, exceptionState);
         break;
     }
     default:
         if (source->isShadowRoot()) {
             // ShadowRoot cannot disconnect itself from the host node.
             exceptionState.throwDOMException(HierarchyRequestError, "The node provided is a shadow root, which may not be adopted.");
             return nullptr;
         }
 
@@ skipping 33 matching lines @@
         return qName.namespaceURI() == XMLNSNames::xmlnsNamespaceURI;
     return qName.namespaceURI() != XMLNSNames::xmlnsNamespaceURI;
 }
 
 bool Document::hasValidNamespaceForAttributes(const QualifiedName& qName)
 {
     return hasValidNamespaceForElements(qName);
 }
 
 // FIXME: This should really be in a possible ElementFactory class
-PassRefPtrWillBeRawPtr<Element> Document::createElement(const QualifiedName& qName, bool createdByParser)
+RawPtr<Element> Document::createElement(const QualifiedName& qName, bool createdByParser)
 {
-    RefPtrWillBeRawPtr<Element> e = nullptr;
+    RawPtr<Element> e = nullptr;
 
     // FIXME: Use registered namespaces and look up in a hash to find the right factory.
     if (qName.namespaceURI() == xhtmlNamespaceURI)
         e = HTMLElementFactory::createHTMLElement(qName.localName(), *this, 0, createdByParser);
     else if (qName.namespaceURI() == SVGNames::svgNamespaceURI)
         e = SVGElementFactory::createSVGElement(qName.localName(), *this, createdByParser);
 
     if (e)
         m_sawElementsInKnownNamespaces = true;
     else
@@ skipping 136 matching lines @@
 }
 
 Element* Document::elementFromPoint(int x, int y) const
 {
     if (!layoutView())
         return 0;
 
     return TreeScope::elementFromPoint(x, y);
 }
 
-WillBeHeapVector<RawPtrWillBeMember<Element>> Document::elementsFromPoint(int x, int y) const
+HeapVector<Member<Element>> Document::elementsFromPoint(int x, int y) const
 {
     if (!layoutView())
-        return WillBeHeapVector<RawPtrWillBeMember<Element>>();
+        return HeapVector<Member<Element>>();
     return TreeScope::elementsFromPoint(x, y);
 }
 
-PassRefPtrWillBeRawPtr<Range> Document::caretRangeFromPoint(int x, int y)
+RawPtr<Range> Document::caretRangeFromPoint(int x, int y)
 {
     if (!layoutView())
         return nullptr;
 
     HitTestResult result = hitTestInDocument(this, x, y);
     PositionWithAffinity positionWithAffinity = result.position();
     if (positionWithAffinity.position().isNull())
         return nullptr;
 
     Position rangeCompliantPosition = positionWithAffinity.position().parentAnchoredEquivalent();
@@ skipping 266 matching lines @@
 FrameHost* Document::frameHost() const
 {
     return m_frame ? m_frame->host() : 0;
 }
 
 Settings* Document::settings() const
 {
     return m_frame ? m_frame->settings() : 0;
 }
 
-PassRefPtrWillBeRawPtr<Range> Document::createRange()
+RawPtr<Range> Document::createRange()
 {
     return Range::create(*this);
 }
 
-PassRefPtrWillBeRawPtr<NodeIterator> Document::createNodeIterator(Node* root, unsigned whatToShow, PassRefPtrWillBeRawPtr<NodeFilter> filter)
+RawPtr<NodeIterator> Document::createNodeIterator(Node* root, unsigned whatToShow, RawPtr<NodeFilter> filter)
 {
     ASSERT(root);
     return NodeIterator::create(root, whatToShow, filter);
 }
 
-PassRefPtrWillBeRawPtr<TreeWalker> Document::createTreeWalker(Node* root, unsigned whatToShow, PassRefPtrWillBeRawPtr<NodeFilter> filter)
+RawPtr<TreeWalker> Document::createTreeWalker(Node* root, unsigned whatToShow, RawPtr<NodeFilter> filter)
 {
     ASSERT(root);
     return TreeWalker::create(root, whatToShow, filter);
 }
 
 bool Document::needsLayoutTreeUpdate() const
 {
     if (!isActive() || !view())
         return false;
     if (needsFullLayoutTreeUpdate())
@@ skipping 70 matching lines @@
         return;
     if (!childNeedsStyleInvalidation())
         return;
     TRACE_EVENT0("blink", "Document::updateStyleInvalidationIfNeeded");
     styleEngine().styleInvalidator().invalidate(*this);
 }
 
 void Document::setupFontBuilder(ComputedStyle& documentStyle)
 {
     FontBuilder fontBuilder(*this);
-    RefPtrWillBeRawPtr<CSSFontSelector> selector = styleEngine().fontSelector();
+    RawPtr<CSSFontSelector> selector = styleEngine().fontSelector();
     fontBuilder.createFontForDocument(selector, documentStyle);
 }
 
 void Document::inheritHtmlAndBodyElementStyles(StyleRecalcChange change)
 {
     ASSERT(inStyleRecalc());
     ASSERT(documentElement());
 
     bool didRecalcDocumentElement = false;
     RefPtr<ComputedStyle> documentElementStyle = documentElement()->mutableComputedStyle();
@@ skipping 178 matching lines @@
     // tear down the layout tree or (unfortunately) run script. Kill the whole layoutObject if
     // someone managed to get into here from inside layout or paint.
     RELEASE_ASSERT(!view()->isInPerformLayout());
     RELEASE_ASSERT(!view()->isPainting());
 
     // Script can run below in WidgetUpdates, so protect the LocalFrame.
     // TODO(esprehn): This should actually crash because of the ScriptForbiddenScope,
     // for an example stack see crbug.com/536194, it seems like we should just use
     // a PluginScriptForbiddenScope to block all script from running inside here
     // to avoid the crash.
-    RefPtrWillBeRawPtr<LocalFrame> protect(m_frame.get());
+    RawPtr<LocalFrame> protect(m_frame.get());
 
     TRACE_EVENT_BEGIN1("blink,devtools.timeline", "UpdateLayoutTree", "beginData", InspectorRecalculateStylesEvent::data(frame()));
     TRACE_EVENT_SCOPED_SAMPLING_STATE("blink", "UpdateLayoutTree");
 
     unsigned startElementCount = styleEngine().styleForElementCount();
 
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willRecalculateStyle(this);
 
     DocumentAnimations::updateAnimationTimingIfNeeded(*this);
     evaluateMediaQueryListIfNeeded();
@@ skipping 149 matching lines @@
         return;
     updateLayoutIgnorePendingStylesheets();
 }
 
 void Document::updateLayout()
 {
     ASSERT(isMainThread());
 
     ScriptForbiddenScope forbidScript;
 
-    RefPtrWillBeRawPtr<FrameView> frameView = view();
+    RawPtr<FrameView> frameView = view();
     if (frameView && frameView->isInPerformLayout()) {
         // View layout should not be re-entrant.
         ASSERT_NOT_REACHED();
         return;
     }
 
     if (HTMLFrameOwnerElement* owner = ownerElement())
         owner->document().updateLayout();
 
     updateLayoutTree();
@@ skipping 194 matching lines @@
     m_useElementsNeedingUpdate.remove(&element);
 }
 
 void Document::updateUseShadowTreesIfNeeded()
 {
     ScriptForbiddenScope forbidScript;
 
     if (m_useElementsNeedingUpdate.isEmpty())
         return;
 
-    WillBeHeapVector<RawPtrWillBeMember<SVGUseElement>> elements;
+    HeapVector<Member<SVGUseElement>> elements;
     copyToVector(m_useElementsNeedingUpdate, elements);
     m_useElementsNeedingUpdate.clear();
 
     for (SVGUseElement* element : elements)
         element->buildPendingResource();
 }
 
 StyleResolver* Document::styleResolver() const
 {
     return m_styleEngine->resolver();
@@ skipping 80 matching lines @@
         m_layoutView->setIsInWindow(false);
 
     if (registrationContext())
         registrationContext()->documentWasDetached();
 
     m_hoverNode = nullptr;
     m_activeHoverElement = nullptr;
     m_autofocusElement = nullptr;
 
     if (m_focusedElement.get()) {
-        RefPtrWillBeRawPtr<Element> oldFocusedElement = m_focusedElement;
+        RawPtr<Element> oldFocusedElement = m_focusedElement;
         m_focusedElement = nullptr;
         if (frameHost())
             frameHost()->chromeClient().focusedNodeChanged(oldFocusedElement.get(), nullptr);
     }
     m_sequentialFocusNavigationStartingPoint = nullptr;
 
     if (this == &axObjectCacheOwner())
         clearAXObjectCache();
 
     m_layoutView = nullptr;
@@ skipping 119 matching lines @@
 }
 
 CanvasFontCache* Document::canvasFontCache()
 {
     if (!m_canvasFontCache)
         m_canvasFontCache = CanvasFontCache::create(*this);
 
     return m_canvasFontCache.get();
 }
 
-PassRefPtrWillBeRawPtr<DocumentParser> Document::createParser()
+RawPtr<DocumentParser> Document::createParser()
 {
     if (isHTMLDocument()) {
         bool reportErrors = InspectorInstrumentation::collectingHTMLParseErrors(this);
         return HTMLDocumentParser::create(toHTMLDocument(*this), reportErrors, m_parserSyncPolicy);
     }
     // FIXME: this should probably pass the frame instead
     return XMLDocumentParser::create(*this, view());
 }
 
 bool Document::isFrameSet() const
@@ skipping 72 matching lines @@
     m_parser.clear();
 }
 
 void Document::cancelParsing()
 {
     detachParser();
     setParsingState(FinishedParsing);
     setReadyState(Complete);
 }
 
-PassRefPtrWillBeRawPtr<DocumentParser> Document::implicitOpen(ParserSynchronizationPolicy parserSyncPolicy)
+RawPtr<DocumentParser> Document::implicitOpen(ParserSynchronizationPolicy parserSyncPolicy)
 {
     detachParser();
 
     removeChildren();
     ASSERT(!m_focusedElement);
 
     setCompatibilityMode(NoQuirksMode);
 
     if (!threadedParsingEnabledForTesting())
         parserSyncPolicy = ForceSynchronousParsing;
@@ skipping 25 matching lines @@
         return 0;
 
     for (HTMLElement* child = Traversal<HTMLElement>::firstChild(*documentElement()); child; child = Traversal<HTMLElement>::nextSibling(*child)) {
         if (isHTMLBodyElement(*child))
             return toHTMLBodyElement(child);
     }
 
     return 0;
 }
 
-void Document::setBody(PassRefPtrWillBeRawPtr<HTMLElement> prpNewBody, ExceptionState& exceptionState)
+void Document::setBody(RawPtr<HTMLElement> prpNewBody, ExceptionState& exceptionState)
 {
-    RefPtrWillBeRawPtr<HTMLElement> newBody = prpNewBody;
+    RawPtr<HTMLElement> newBody = prpNewBody;
 
     if (!newBody) {
         exceptionState.throwDOMException(HierarchyRequestError, ExceptionMessages::argumentNullOrIncorrectType(1, "HTMLElement"));
         return;
     }
     if (!documentElement()) {
         exceptionState.throwDOMException(HierarchyRequestError, "No document element exists.");
         return;
     }
 
@@ skipping 59 matching lines @@
     }
 
     close();
 }
 
 void Document::close()
 {
     if (!scriptableDocumentParser() || !scriptableDocumentParser()->wasCreatedByScript() || !scriptableDocumentParser()->isParsing())
         return;
 
-    if (RefPtrWillBeRawPtr<DocumentParser> parser = m_parser)
+    if (RawPtr<DocumentParser> parser = m_parser)
         parser->finish();
 
     if (!m_frame) {
         // Because we have no frame, we don't know if all loading has completed,
         // so we just call implicitClose() immediately. FIXME: This might fire
         // the load event prematurely <http://bugs.webkit.org/show_bug.cgi?id=14568>.
         implicitClose();
         return;
     }
 
     m_frame->loader().checkCompleted();
 }
 
 void Document::implicitClose()
 {
     ASSERT(!inStyleRecalc());
     if (processingLoadEvent() || !m_parser)
         return;
     if (frame() && frame()->navigationScheduler().locationChangePending()) {
         suppressLoadEvent();
         return;
     }
 
     // The call to dispatchWindowLoadEvent (from documentWasClosed()) can detach
     // the LocalDOMWindow and cause it (and its attached Document) to be
     // destroyed.
-    RefPtrWillBeRawPtr<LocalDOMWindow> protectedWindow(this->domWindow());
+    RawPtr<LocalDOMWindow> protectedWindow(this->domWindow());
 
     m_loadEventProgress = LoadEventInProgress;
 
     ScriptableDocumentParser* parser = scriptableDocumentParser();
     m_wellFormed = parser && parser->wellFormed();
 
     // We have to clear the parser, in case someone document.write()s from the
     // onLoad event handler, as in Radar 3206524.
     detachParser();
 
@@ skipping 67 matching lines @@
 {
     if (!m_domWindow)
         return true;
 
     if (!body())
         return true;
 
     if (processingBeforeUnload())
         return false;
 
-    RefPtrWillBeRawPtr<Document> protect(this);
+    RawPtr<Document> protect(this);
 
-    RefPtrWillBeRawPtr<BeforeUnloadEvent> beforeUnloadEvent = BeforeUnloadEvent::create();
+    RawPtr<BeforeUnloadEvent> beforeUnloadEvent = BeforeUnloadEvent::create();
     m_loadEventProgress = BeforeUnloadEventInProgress;
     m_domWindow->dispatchEvent(beforeUnloadEvent.get(), this);
     m_loadEventProgress = BeforeUnloadEventCompleted;
     if (!beforeUnloadEvent->defaultPrevented())
         defaultEventHandler(beforeUnloadEvent.get());
     if (!frame() || beforeUnloadEvent->returnValue().isNull())
         return true;
 
     if (didAllowNavigation) {
         addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, "Blocked attempt to show multiple 'beforeunload' confirmation panels for a single navigation."));
         return true;
     }
 
     String text = beforeUnloadEvent->returnValue();
     if (chromeClient.openBeforeUnloadConfirmPanel(text, m_frame, isReload)) {
         didAllowNavigation = true;
         return true;
     }
     return false;
 }
 
 void Document::dispatchUnloadEvents()
 {
     PluginScriptForbiddenScope forbidPluginDestructorScripting;
-    RefPtrWillBeRawPtr<Document> protect(this);
+    RawPtr<Document> protect(this);
     if (m_parser)
         m_parser->stopParsing();
 
     if (m_loadEventProgress == LoadEventNotRun)
         return;
 
     if (m_loadEventProgress <= UnloadEventInProgress) {
         Element* currentFocusedElement = focusedElement();
         if (isHTMLInputElement(currentFocusedElement))
             toHTMLInputElement(*currentFocusedElement).endEditing();
@@ skipping 11 matching lines @@
                 // other notifications as we're about to be unloaded.
                 dispatchEvent(Event::createBubble(EventTypeNames::visibilitychange));
                 dispatchEvent(Event::createBubble(EventTypeNames::webkitvisibilitychange));
             }
             if (!m_frame)
                 return;
 
             // The DocumentLoader (and thus its DocumentLoadTiming) might get destroyed
             // while dispatching the event, so protect it to prevent writing the end
             // time into freed memory.
-            RefPtrWillBeRawPtr<DocumentLoader> documentLoader = m_frame->loader().provisionalDocumentLoader();
+            RawPtr<DocumentLoader> documentLoader = m_frame->loader().provisionalDocumentLoader();
             m_loadEventProgress = UnloadEventInProgress;
-            RefPtrWillBeRawPtr<Event> unloadEvent(Event::create(EventTypeNames::unload));
+            RawPtr<Event> unloadEvent(Event::create(EventTypeNames::unload));
             if (documentLoader && !documentLoader->timing().unloadEventStart() && !documentLoader->timing().unloadEventEnd()) {
                 DocumentLoadTiming& timing = documentLoader->timing();
                 ASSERT(timing.navigationStart());
                 timing.markUnloadEventStart();
                 m_frame->localDOMWindow()->dispatchEvent(unloadEvent, this);
                 timing.markUnloadEventEnd();
             } else {
                 m_frame->localDOMWindow()->dispatchEvent(unloadEvent, m_frame->document());
             }
         }
@@ skipping 150 matching lines @@
     return &m_timers;
 }
 
 EventTarget* Document::errorEventTarget()
 {
     return domWindow();
 }
 
 void Document::logExceptionToConsole(const String& errorMessage, int scriptId, const String& sourceURL, int lineNumber, int columnNumber, PassRefPtr<ScriptCallStack> callStack)
 {
-    RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, errorMessage, sourceURL, lineNumber, columnNumber);
+    RawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, errorMessage, sourceURL, lineNumber, columnNumber);
     consoleMessage->setScriptId(scriptId);
     consoleMessage->setCallStack(callStack);
     addConsoleMessage(consoleMessage.release());
 }
 
 void Document::setURL(const KURL& url)
 {
     const KURL& newURL = url.isEmpty() ? blankURL() : url;
     if (newURL == m_url)
         return;
@@ skipping 372 matching lines @@
     if (numElements > 1 || numDoctypes > 1) {
         exceptionState.throwDOMException(HierarchyRequestError,
             String::format("Only one %s on document allowed.",
             numElements > 1 ? "element" : "doctype"));
         return false;
     }
 
     return true;
 }
 
-PassRefPtrWillBeRawPtr<Node> Document::cloneNode(bool deep)
+RawPtr<Node> Document::cloneNode(bool deep)
 {
-    RefPtrWillBeRawPtr<Document> clone = cloneDocumentWithoutChildren();
+    RawPtr<Document> clone = cloneDocumentWithoutChildren();
     clone->cloneDataFromDocument(*this);
     if (deep)
         cloneChildNodes(clone.get());
     return clone.release();
 }
 
-PassRefPtrWillBeRawPtr<Document> Document::cloneDocumentWithoutChildren()
+RawPtr<Document> Document::cloneDocumentWithoutChildren()
 {
     DocumentInit init(url());
     if (isXMLDocument()) {
         if (isXHTMLDocument())
             return XMLDocument::createXHTML(init.withRegistrationContext(registrationContext()));
         return XMLDocument::create(init);
     }
     return create(init);
 }
 
@@ skipping 109 matching lines @@
         // We need to manually repaint because we avoid doing all repaints in layout or style
         // recalc while sheets are still loading to avoid FOUC.
         m_pendingSheetLayout = IgnoreLayoutWithPendingSheets;
 
         ASSERT(layoutView() || importsController());
         if (layoutView())
             layoutView()->invalidatePaintForViewAndCompositedLayers();
     }
 }
 
-void Document::setHoverNode(PassRefPtrWillBeRawPtr<Node> newHoverNode)
+void Document::setHoverNode(RawPtr<Node> newHoverNode)
 {
     m_hoverNode = newHoverNode;
 }
 
-void Document::setActiveHoverElement(PassRefPtrWillBeRawPtr<Element> newActiveElement)
+void Document::setActiveHoverElement(RawPtr<Element> newActiveElement)
 {
     if (!newActiveElement) {
         m_activeHoverElement.clear();
         return;
     }
 
     m_activeHoverElement = newActiveElement;
 }
 
 void Document::removeFocusedElementOfSubtree(Node* node, bool amongChildrenOnly)
@@ skipping 51 matching lines @@
 {
     return m_annotatedRegions;
 }
 
 void Document::setAnnotatedRegions(const Vector<AnnotatedRegionValue>& regions)
 {
     m_annotatedRegions = regions;
     setAnnotatedRegionsDirty(false);
 }
 
-bool Document::setFocusedElement(PassRefPtrWillBeRawPtr<Element> prpNewFocusedElement, const FocusParams& params)
+bool Document::setFocusedElement(RawPtr<Element> prpNewFocusedElement, const FocusParams& params)
 {
     ASSERT(!m_lifecycle.inDetach());
 
     m_clearFocusedElementTimer.stop();
 
-    RefPtrWillBeRawPtr<Element> newFocusedElement = prpNewFocusedElement;
+    RawPtr<Element> newFocusedElement = prpNewFocusedElement;
 
     // Make sure newFocusedNode is actually in this document
     if (newFocusedElement && (newFocusedElement->document() != this))
         return true;
 
     if (NodeChildRemovalTracker::isBeingRemoved(newFocusedElement.get()))
         return true;
 
     if (m_focusedElement == newFocusedElement)
         return true;
 
     bool focusChangeBlocked = false;
-    RefPtrWillBeRawPtr<Element> oldFocusedElement = m_focusedElement;
+    RawPtr<Element> oldFocusedElement = m_focusedElement;
     m_focusedElement = nullptr;
 
     // Remove focus from the existing focus node (if any)
     if (oldFocusedElement) {
         oldFocusedElement->setFocus(false);
 
         // Dispatch the blur event and let the node do any other blur related activities (important for text fields)
         // If page lost focus, blur event will have already been dispatched
         if (page() && (page()->focusController().isFocused())) {
             oldFocusedElement->dispatchBlurEvent(newFocusedElement.get(), params.type, params.sourceCapabilities);
@@ skipping 231 matching lines @@
 
 void Document::detachNodeIterator(NodeIterator* ni)
 {
     // The node iterator can be detached without having been attached if its root node didn't have a document
     // when the iterator was created, but has it now.
     m_nodeIterators.remove(ni);
 }
 
 void Document::moveNodeIteratorsToNewDocument(Node& node, Document& newDocument)
 {
-    WillBeHeapHashSet<RawPtrWillBeWeakMember<NodeIterator>> nodeIteratorsList = m_nodeIterators;
+    HeapHashSet<WeakMember<NodeIterator>> nodeIteratorsList = m_nodeIterators;
     for (NodeIterator* ni : nodeIteratorsList) {
         if (ni->root() == node) {
             detachNodeIterator(ni);
             newDocument.attachNodeIterator(ni);
         }
     }
 }
 
 void Document::updateRangesAfterChildrenChanged(ContainerNode* container)
 {
@@ skipping 82 matching lines @@
 {
     for (Range* range : m_ranges)
         range->didSplitTextNode(oldNode);
 
     if (m_frame)
         m_frame->selection().didSplitTextNode(oldNode);
 
     // FIXME: This should update markers for spelling and grammar checking.
 }
 
-void Document::setWindowAttributeEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener> listener)
+void Document::setWindowAttributeEventListener(const AtomicString& eventType, RawPtr<EventListener> listener)
 {
     LocalDOMWindow* domWindow = this->domWindow();
     if (!domWindow)
         return;
     domWindow->setAttributeEventListener(eventType, listener);
 }
 
 EventListener* Document::getWindowAttributeEventListener(const AtomicString& eventType)
 {
     LocalDOMWindow* domWindow = this->domWindow();
     if (!domWindow)
         return 0;
     return domWindow->getAttributeEventListener(eventType);
 }
 
 EventQueue* Document::getEventQueue() const
 {
     if (!m_domWindow)
         return 0;
     return m_domWindow->getEventQueue();
 }
 
-void Document::enqueueAnimationFrameEvent(PassRefPtrWillBeRawPtr<Event> event)
+void Document::enqueueAnimationFrameEvent(RawPtr<Event> event)
 {
     ensureScriptedAnimationController().enqueueEvent(event);
 }
 
-void Document::enqueueUniqueAnimationFrameEvent(PassRefPtrWillBeRawPtr<Event> event)
+void Document::enqueueUniqueAnimationFrameEvent(RawPtr<Event> event)
 {
     ensureScriptedAnimationController().enqueuePerFrameEvent(event);
 }
 
 void Document::enqueueScrollEventForNode(Node* target)
 {
     // Per the W3C CSSOM View Module only scroll events fired at the document should bubble.
-    RefPtrWillBeRawPtr<Event> scrollEvent = target->isDocumentNode() ? Event::createBubble(EventTypeNames::scroll) : Event::create(EventTypeNames::scroll);
+    RawPtr<Event> scrollEvent = target->isDocumentNode() ? Event::createBubble(EventTypeNames::scroll) : Event::create(EventTypeNames::scroll);
     scrollEvent->setTarget(target);
     ensureScriptedAnimationController().enqueuePerFrameEvent(scrollEvent.release());
 }
 
 void Document::enqueueResizeEvent()
 {
-    RefPtrWillBeRawPtr<Event> event = Event::create(EventTypeNames::resize);
+    RawPtr<Event> event = Event::create(EventTypeNames::resize);
     event->setTarget(domWindow());
     ensureScriptedAnimationController().enqueuePerFrameEvent(event.release());
 }
 
-void Document::enqueueMediaQueryChangeListeners(WillBeHeapVector<RefPtrWillBeMember<MediaQueryListListener>>& listeners)
+void Document::enqueueMediaQueryChangeListeners(HeapVector<Member<MediaQueryListListener>>& listeners)
 {
     ensureScriptedAnimationController().enqueueMediaQueryChangeListeners(listeners);
 }
 
 void Document::dispatchEventsForPrinting()
 {
     if (!m_scriptedAnimationController)
         return;
     m_scriptedAnimationController->dispatchEventsAndCallbacksForPrinting();
 }
@@ skipping 11 matching lines @@
     }
     return *m_accessEntryFromURL;
 }
 
 void Document::registerEventFactory(PassOwnPtr<EventFactoryBase> eventFactory)
 {
     ASSERT(!eventFactories().contains(eventFactory.get()));
     eventFactories().add(eventFactory);
 }
 
-PassRefPtrWillBeRawPtr<Event> Document::createEvent(ExecutionContext* executionContext, const String& eventType, ExceptionState& exceptionState)
+RawPtr<Event> Document::createEvent(ExecutionContext* executionContext, const String& eventType, ExceptionState& exceptionState)
 {
-    RefPtrWillBeRawPtr<Event> event = nullptr;
+    RawPtr<Event> event = nullptr;
     for (const auto& factory : eventFactories()) {
         event = factory->create(executionContext, eventType);
         if (event)
             return event.release();
     }
     exceptionState.throwDOMException(NotSupportedError, "The provided event type ('" + eventType + "') is invalid.");
     return nullptr;
 }
 
 void Document::addMutationEventListenerTypeIfEnabled(ListenerType listenerType)
@@ skipping 568 matching lines @@
         if (!equalIgnoringCase(linkElement->type(), openSearchMIMEType) || !equalIgnoringCase(linkElement->rel(), openSearchRelation))
             continue;
         if (linkElement->href().isEmpty())
             continue;
         return linkElement->href();
     }
 
     return KURL();
 }
 
-void Document::pushCurrentScript(PassRefPtrWillBeRawPtr<HTMLScriptElement> newCurrentScript)
+void Document::pushCurrentScript(RawPtr<HTMLScriptElement> newCurrentScript)
 {
     ASSERT(newCurrentScript);
     m_currentScriptStack.append(newCurrentScript);
 }
 
 void Document::popCurrentScript()
 {
     ASSERT(!m_currentScriptStack.isEmpty());
     m_currentScriptStack.removeLast();
 }
@@ skipping 38 matching lines @@
     // FIXME: Not clear what topDocument() should do in the OOPI case--should it return the topmost
     // available Document, or something else?
     Document* doc = const_cast<Document*>(this);
     for (HTMLFrameOwnerElement* element = doc->ownerElement(); element; element = doc->ownerElement())
         doc = &element->document();
 
     ASSERT(doc);
     return *doc;
 }
 
-WeakPtrWillBeRawPtr<Document> Document::contextDocument()
+RawPtr<Document> Document::contextDocument()
 {
     if (m_contextDocument)
         return m_contextDocument;
     if (m_frame) {
         return createWeakPtr();
     }
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<Attr> Document::createAttribute(const AtomicString& name, ExceptionState& exceptionState)
+RawPtr<Attr> Document::createAttribute(const AtomicString& name, ExceptionState& exceptionState)
 {
     if (isHTMLDocument() && name != name.lower())
         UseCounter::count(*this, UseCounter::HTMLDocumentCreateAttributeNameNotLowercase);
     return createAttributeNS(nullAtom, name, exceptionState, true);
 }
 
-PassRefPtrWillBeRawPtr<Attr> Document::createAttributeNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionState& exceptionState, bool shouldIgnoreNamespaceChecks)
+RawPtr<Attr> Document::createAttributeNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionState& exceptionState, bool shouldIgnoreNamespaceChecks)
 {
     AtomicString prefix, localName;
     if (!parseQualifiedName(qualifiedName, prefix, localName, exceptionState))
         return nullptr;
 
     QualifiedName qName(prefix, localName, namespaceURI);
 
     if (!shouldIgnoreNamespaceChecks && !hasValidNamespaceForAttributes(qName)) {
         exceptionState.throwDOMException(NamespaceError, "The namespace URI provided ('" + namespaceURI + "') is not valid for the qualified name provided ('" + qualifiedName + "').");
         return nullptr;
     }
 
     return Attr::create(*this, qName, emptyAtom);
 }
 
 const SVGDocumentExtensions* Document::svgExtensions()
 {
     return m_svgExtensions.get();
 }
 
 SVGDocumentExtensions& Document::accessSVGExtensions()
 {
     if (!m_svgExtensions)
-        m_svgExtensions = adoptPtrWillBeNoop(new SVGDocumentExtensions(this));
+        m_svgExtensions = new SVGDocumentExtensions(this);
     return *m_svgExtensions;
 }
 
 bool Document::hasSVGRootNode() const
 {
     return isSVGSVGElement(documentElement());
 }
 
-PassRefPtrWillBeRawPtr<HTMLCollection> Document::images()
+RawPtr<HTMLCollection> Document::images()
 {
     return ensureCachedCollection<HTMLCollection>(DocImages);
 }
 
-PassRefPtrWillBeRawPtr<HTMLCollection> Document::applets()
+RawPtr<HTMLCollection> Document::applets()
 {
     return ensureCachedCollection<HTMLCollection>(DocApplets);
 }
 
-PassRefPtrWillBeRawPtr<HTMLCollection> Document::embeds()
+RawPtr<HTMLCollection> Document::embeds()
 {
     return ensureCachedCollection<HTMLCollection>(DocEmbeds);
 }
 
-PassRefPtrWillBeRawPtr<HTMLCollection> Document::scripts()
+RawPtr<HTMLCollection> Document::scripts()
 {
     return ensureCachedCollection<HTMLCollection>(DocScripts);
 }
 
-PassRefPtrWillBeRawPtr<HTMLCollection> Document::links()
+RawPtr<HTMLCollection> Document::links()
 {
     return ensureCachedCollection<HTMLCollection>(DocLinks);
 }
 
-PassRefPtrWillBeRawPtr<HTMLCollection> Document::forms()
+RawPtr<HTMLCollection> Document::forms()
 {
     return ensureCachedCollection<HTMLCollection>(DocForms);
 }
 
-PassRefPtrWillBeRawPtr<HTMLCollection> Document::anchors()
+RawPtr<HTMLCollection> Document::anchors()
 {
     return ensureCachedCollection<HTMLCollection>(DocAnchors);
 }
 
-PassRefPtrWillBeRawPtr<HTMLAllCollection> Document::allForBinding()
+RawPtr<HTMLAllCollection> Document::allForBinding()
 {
     UseCounter::count(*this, UseCounter::DocumentAll);
     return all();
 }
 
-PassRefPtrWillBeRawPtr<HTMLAllCollection> Document::all()
+RawPtr<HTMLAllCollection> Document::all()
 {
     return ensureCachedCollection<HTMLAllCollection>(DocAll);
 }
 
-PassRefPtrWillBeRawPtr<HTMLCollection> Document::windowNamedItems(const AtomicString& name)
+RawPtr<HTMLCollection> Document::windowNamedItems(const AtomicString& name)
 {
     return ensureCachedCollection<WindowNameCollection>(WindowNamedItems, name);
 }
 
-PassRefPtrWillBeRawPtr<DocumentNameCollection> Document::documentNamedItems(const AtomicString& name)
+RawPtr<DocumentNameCollection> Document::documentNamedItems(const AtomicString& name)
 {
     return ensureCachedCollection<DocumentNameCollection>(DocumentNamedItems, name);
 }
 
 void Document::finishedParsing()
 {
     ASSERT(!scriptableDocumentParser() || !m_parser->isParsing());
     ASSERT(!scriptableDocumentParser() || m_readyState != Loading);
     setParsingState(InDOMContentLoaded);
 
     // FIXME: DOMContentLoaded is dispatched synchronously, but this should be dispatched in a queued task,
     // See https://crbug.com/425790
     if (!m_documentTiming.domContentLoadedEventStart())
         m_documentTiming.markDomContentLoadedEventStart();
     dispatchEvent(Event::createBubble(EventTypeNames::DOMContentLoaded));
     if (!m_documentTiming.domContentLoadedEventEnd())
         m_documentTiming.markDomContentLoadedEventEnd();
     setParsingState(FinishedParsing);
 
     // The microtask checkpoint or the loader's finishedParsing() method may invoke script that causes this object to
     // be dereferenced (when this document is in an iframe and the onload causes the iframe's src to change).
     // Keep it alive until we are done.
-    RefPtrWillBeRawPtr<Document> protect(this);
+    RawPtr<Document> protect(this);
 
     // Ensure Custom Element callbacks are drained before DOMContentLoaded.
     // FIXME: Remove this ad-hoc checkpoint when DOMContentLoaded is dispatched in a
     // queued task, which will do a checkpoint anyway. https://crbug.com/425790
     Microtask::performCheckpoint(V8PerIsolateData::mainThreadIsolate());
 
-    if (RefPtrWillBeRawPtr<LocalFrame> frame = this->frame()) {
+    if (RawPtr<LocalFrame> frame = this->frame()) {
         // Don't update the layout tree if we haven't requested the main resource yet to avoid
         // adding extra latency. Note that the first layout tree update can be expensive since it
         // triggers the parsing of the default stylesheets which are compiled-in.
         const bool mainResourceWasAlreadyRequested = frame->loader().stateMachine()->committedFirstRealDocumentLoad();
 
         // FrameLoader::finishedParsing() might end up calling Document::implicitClose() if all
         // resource loads are complete. HTMLObjectElements can start loading their resources from
         // post attach callbacks triggered by recalcStyle().  This means if we parse out an <object>
         // tag and then reach the end of the document without updating styles, we might not have yet
         // started the resource load and might fire the window load event too early.  To avoid this
@@ skipping 201 matching lines @@
         setBaseURLOverride(initializer.parentBaseURL());
     }
 
     if (getSecurityOrigin()->isUnique() && SecurityOrigin::create(m_url)->isPotentiallyTrustworthy())
         getSecurityOrigin()->setUniqueOriginIsPotentiallyTrustworthy(true);
 
     if (getSecurityOrigin()->hasSuborigin())
         enforceSuborigin(*getSecurityOrigin()->suborigin());
 }
 
-void Document::initContentSecurityPolicy(PassRefPtrWillBeRawPtr<ContentSecurityPolicy> csp)
+void Document::initContentSecurityPolicy(RawPtr<ContentSecurityPolicy> csp)
 {
     setContentSecurityPolicy(csp ? csp : ContentSecurityPolicy::create());
     if (m_frame && m_frame->tree().parent() && m_frame->tree().parent()->isLocalFrame()) {
         ContentSecurityPolicy* parentCSP = toLocalFrame(m_frame->tree().parent())->document()->contentSecurityPolicy();
         if (shouldInheritSecurityOriginFromOwner(m_url)) {
             contentSecurityPolicy()->copyStateFrom(parentCSP);
         } else if (isPluginDocument()) {
             // Per CSP2, plugin-types for plugin documents in nested browsing
             // contexts gets inherited from the parent.
             contentSecurityPolicy()->copyPluginTypesFrom(parentCSP);
@@ skipping 127 matching lines @@
 {
     if (equalIgnoringCase(dnsPrefetchControl, "on") && !m_haveExplicitlyDisabledDNSPrefetch) {
         m_isDNSPrefetchEnabled = true;
         return;
     }
 
     m_isDNSPrefetchEnabled = false;
     m_haveExplicitlyDisabledDNSPrefetch = true;
 }
 
-WeakPtrWillBeRawPtr<Document> Document::createWeakPtr()
+RawPtr<Document> Document::createWeakPtr()
 {
 #if ENABLE(OILPAN)
     return this;
 #else
     return m_weakFactory.createWeakPtr();
 #endif
 }
 
 IntersectionObserverController* Document::intersectionObserverController()
 {
@@ skipping 12 matching lines @@
     if (!m_intersectionObserverData)
         m_intersectionObserverData = new NodeIntersectionObserverData();
     return *m_intersectionObserverData;
 }
 
 void Document::reportBlockedScriptExecutionToInspector(const String& directiveText)
 {
     InspectorInstrumentation::scriptExecutionBlockedByCSP(this, directiveText);
 }
 
-void Document::addConsoleMessage(PassRefPtrWillBeRawPtr<ConsoleMessage> consoleMessage)
+void Document::addConsoleMessage(RawPtr<ConsoleMessage> consoleMessage)
 {
     if (!isContextThread()) {
         m_taskRunner->postTask(BLINK_FROM_HERE, AddConsoleMessageTask::create(consoleMessage->source(), consoleMessage->level(), consoleMessage->message()));
         return;
     }
 
     if (!m_frame)
         return;
 
     if (!consoleMessage->getScriptState() && consoleMessage->url().isNull() && !consoleMessage->lineNumber()) {
@@ skipping 215 matching lines @@
     return ensureScriptedIdleTaskController().registerCallback(callback, options);
 }
 
 void Document::cancelIdleCallback(int id)
 {
     if (!m_scriptedIdleTaskController)
         return;
     m_scriptedIdleTaskController->cancelCallback(id);
 }
 
-PassRefPtrWillBeRawPtr<Touch> Document::createTouch(DOMWindow* window, EventTarget* target, int identifier, double pageX, double pageY, double screenX, double screenY, double radiusX, double radiusY, float rotationAngle, float force) const
+RawPtr<Touch> Document::createTouch(DOMWindow* window, EventTarget* target, int identifier, double pageX, double pageY, double screenX, double screenY, double radiusX, double radiusY, float rotationAngle, float force) const
 {
     // Match behavior from when these types were integers, and avoid surprises from someone explicitly
     // passing Infinity/NaN.
     if (!std::isfinite(pageX))
         pageX = 0;
     if (!std::isfinite(pageY))
         pageY = 0;
     if (!std::isfinite(screenX))
         screenX = 0;
     if (!std::isfinite(screenY))
         screenY = 0;
     if (!std::isfinite(radiusX))
         radiusX = 0;
     if (!std::isfinite(radiusY))
         radiusY = 0;
     if (!std::isfinite(rotationAngle))
         rotationAngle = 0;
     if (!std::isfinite(force))
         force = 0;
 
     // FIXME: It's not clear from the documentation at
     // http://developer.apple.com/library/safari/#documentation/UserExperience/Reference/DocumentAdditionsReference/DocumentAdditions/DocumentAdditions.html
     // when this method should throw and nor is it by inspection of iOS behavior. It would be nice to verify any cases where it throws under iOS
     // and implement them here. See https://bugs.webkit.org/show_bug.cgi?id=47819
     LocalFrame* frame = window && window->isLocalDOMWindow() ? toLocalDOMWindow(window)->frame() : this->frame();
     return Touch::create(frame, target, identifier, FloatPoint(screenX, screenY), FloatPoint(pageX, pageY), FloatSize(radiusX, radiusY), rotationAngle, force, String());
 }
 
-PassRefPtrWillBeRawPtr<TouchList> Document::createTouchList(WillBeHeapVector<RefPtrWillBeMember<Touch>>& touches) const
+RawPtr<TouchList> Document::createTouchList(HeapVector<Member<Touch>>& touches) const
 {
     return TouchList::adopt(touches);
 }
 
 DocumentLoader* Document::loader() const
 {
     if (!m_frame)
         return 0;
 
     DocumentLoader* loader = m_frame->loader().documentLoader();
@@ skipping 49 matching lines @@
     s_threadedParsingEnabledForTesting = enabled;
 }
 
 bool Document::threadedParsingEnabledForTesting()
 {
     return s_threadedParsingEnabledForTesting;
 }
 
 void Document::setContextFeatures(ContextFeatures& features)
 {
-    m_contextFeatures = PassRefPtrWillBeRawPtr<ContextFeatures>(features);
+    m_contextFeatures = RawPtr<ContextFeatures>(features);
 }
 
 static LayoutObject* nearestCommonHoverAncestor(LayoutObject* obj1, LayoutObject* obj2)
 {
     if (!obj1 || !obj2)
         return 0;
 
     for (LayoutObject* currObj1 = obj1; currObj1; currObj1 = currObj1->hoverAncestor()) {
         for (LayoutObject* currObj2 = obj2; currObj2; currObj2 = currObj2->hoverAncestor()) {
             if (currObj1 == currObj2)
@@ skipping 15 matching lines @@
     while (innerElementInDocument && innerElementInDocument->document() != this) {
         innerElementInDocument->document().updateHoverActiveState(request, innerElementInDocument);
         innerElementInDocument = innerElementInDocument->document().ownerElement();
     }
 
     updateDistribution();
     Element* oldActiveElement = activeHoverElement();
     if (oldActiveElement && !request.active()) {
         // The oldActiveElement layoutObject is null, dropped on :active by setting display: none,
         // for instance. We still need to clear the ActiveChain as the mouse is released.
-        for (RefPtrWillBeRawPtr<Node> node = oldActiveElement; node; node = FlatTreeTraversal::parent(*node)) {
+        for (RawPtr<Node> node = oldActiveElement; node; node = FlatTreeTraversal::parent(*node)) {
             ASSERT(!node->isTextNode());
             node->setActive(false);
             m_userActionElements.setInActiveChain(node.get(), false);
         }
         setActiveHoverElement(nullptr);
     } else {
         Element* newActiveElement = innerElementInDocument;
         if (!oldActiveElement && newActiveElement && !newActiveElement->isDisabledFormControl() && request.active() && !request.touchMove()) {
             // We are setting the :active chain and freezing it. If future moves happen, they
             // will need to reference this chain.
             for (Node* node = newActiveElement; node; node = FlatTreeTraversal::parent(*node)) {
                 ASSERT(!node->isTextNode());
                 m_userActionElements.setInActiveChain(node, true);
             }
             setActiveHoverElement(newActiveElement);
         }
     }
     // If the mouse has just been pressed, set :active on the chain. Those (and only those)
     // nodes should remain :active until the mouse is released.
     bool allowActiveChanges = !oldActiveElement && activeHoverElement();
 
     // If the mouse is down and if this is a mouse move event, we want to restrict changes in
     // :hover/:active to only apply to elements that are in the :active chain that we froze
     // at the time the mouse went down.
     bool mustBeInActiveChain = request.active() && request.move();
 
-    RefPtrWillBeRawPtr<Node> oldHoverNode = hoverNode();
+    RawPtr<Node> oldHoverNode = hoverNode();
 
     // Check to see if the hovered node has changed.
     // If it hasn't, we do not need to do anything.
     Node* newHoverNode = innerElementInDocument;
     while (newHoverNode && !newHoverNode->layoutObject())
         newHoverNode = newHoverNode->parentOrShadowHostNode();
 
     // Update our current hover node.
     setHoverNode(newHoverNode);
 
     // We have two different objects. Fetch their layoutObjects.
     LayoutObject* oldHoverObj = oldHoverNode ? oldHoverNode->layoutObject() : 0;
     LayoutObject* newHoverObj = newHoverNode ? newHoverNode->layoutObject() : 0;
 
     // Locate the common ancestor layout object for the two layoutObjects.
     LayoutObject* ancestor = nearestCommonHoverAncestor(oldHoverObj, newHoverObj);
-    RefPtrWillBeRawPtr<Node> ancestorNode(ancestor ? ancestor->node() : 0);
+    RawPtr<Node> ancestorNode(ancestor ? ancestor->node() : 0);
 
-    WillBeHeapVector<RefPtrWillBeMember<Node>, 32> nodesToRemoveFromChain;
-    WillBeHeapVector<RefPtrWillBeMember<Node>, 32> nodesToAddToChain;
+    HeapVector<Member<Node>, 32> nodesToRemoveFromChain;
+    HeapVector<Member<Node>, 32> nodesToAddToChain;
 
     if (oldHoverObj != newHoverObj) {
         // If the old hovered node is not nil but it's layoutObject is, it was probably detached as part of the :hover style
         // (for instance by setting display:none in the :hover pseudo-class). In this case, the old hovered element (and its ancestors)
         // must be updated, to ensure it's normal style is re-applied.
         if (oldHoverNode && !oldHoverObj) {
             for (Node* node = oldHoverNode.get(); node; node = node->parentNode()) {
                 if (!mustBeInActiveChain || (node->isElementNode() && toElement(node)->inActiveChain()))
                     nodesToRemoveFromChain.append(node);
             }
@@ skipping 94 matching lines @@
     if (m_associatedFormControls.isEmpty())
         m_didAssociateFormControlsTimer.stop();
 }
 
 void Document::didAssociateFormControlsTimerFired(Timer<Document>* timer)
 {
     ASSERT_UNUSED(timer, timer == &m_didAssociateFormControlsTimer);
     if (!frame() || !frame()->page())
         return;
 
-    WillBeHeapVector<RefPtrWillBeMember<Element>> associatedFormControls;
+    HeapVector<Member<Element>> associatedFormControls;
     copyToVector(m_associatedFormControls, associatedFormControls);
 
     frame()->page()->chromeClient().didAssociateFormControls(associatedFormControls, frame());
     m_associatedFormControls.clear();
 }
 
 float Document::devicePixelRatio() const
 {
     return m_frame ? m_frame->devicePixelRatio() : 1.0;
 }
@@ skipping 115 matching lines @@
         return;
 
     styleEngine().platformColorsChanged();
 }
 
 v8::Local<v8::Object> Document::wrap(v8::Isolate* isolate, v8::Local<v8::Object> creationContext)
 {
     // It's possible that no one except for the new wrapper owns this object at
     // this moment, so we have to prevent GC to collect this object until the
     // object gets associated with the wrapper.
-    RefPtrWillBeRawPtr<Document> protect(this);
+    RawPtr<Document> protect(this);
 
     ASSERT(!DOMDataStore::containsWrapper(this, isolate));
 
     const WrapperTypeInfo* wrapperType = wrapperTypeInfo();
 
     if (frame() && frame()->script().initializeMainWorld()) {
         // initializeMainWorld may have created a wrapper for the object, retry from the start.
         v8::Local<v8::Object> wrapper = DOMDataStore::getWrapper(this, isolate);
         if (!wrapper.IsEmpty())
             return wrapper;
@@ skipping 48 matching lines @@
     return Platform::current()->currentThread()->scheduler()->timerTaskRunner();
 }
 
 void Document::enforceStrictMixedContentChecking()
 {
     securityContext().setShouldEnforceStrictMixedContentChecking(true);
     if (frame())
         frame()->loader().client()->didEnforceStrictMixedContentChecking();
 }
 
-PassOwnPtrWillBeRawPtr<OriginTrialContext> Document::createOriginTrialContext()
+RawPtr<OriginTrialContext> Document::createOriginTrialContext()
 {
-    return adoptPtrWillBeNoop(new DocumentOriginTrialContext(this));
+    return new DocumentOriginTrialContext(this);
 }
 
 DEFINE_TRACE(Document)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_importsController);
     visitor->trace(m_docType);
     visitor->trace(m_implementation);
     visitor->trace(m_autofocusElement);
     visitor->trace(m_focusedElement);
@@ skipping 40 matching lines @@
     visitor->trace(m_templateDocumentHost);
     visitor->trace(m_visibilityObservers);
     visitor->trace(m_userActionElements);
     visitor->trace(m_svgExtensions);
     visitor->trace(m_timeline);
     visitor->trace(m_compositorPendingAnimations);
     visitor->trace(m_contextDocument);
     visitor->trace(m_canvasFontCache);
     visitor->trace(m_intersectionObserverController);
     visitor->trace(m_intersectionObserverData);
-    WillBeHeapSupplementable<Document>::trace(visitor);
+    HeapSupplementable<Document>::trace(visitor);
 #endif
     TreeScope::trace(visitor);
     ContainerNode::trace(visitor);
     ExecutionContext::trace(visitor);
     DocumentLifecycleNotifier::trace(visitor);
     SecurityContext::trace(visitor);
 }
 
-template class CORE_TEMPLATE_EXPORT WillBeHeapSupplement<Document>;
+template class CORE_TEMPLATE_EXPORT HeapSupplement<Document>;
 
 } // namespace blink
 
 #ifndef NDEBUG
 using namespace blink;
 void showLiveDocumentInstances()
 {
     Document::WeakDocumentSet& set = Document::liveDocumentSet();
     fprintf(stderr, "There are %u documents currently alive:\n", set.size());
     for (Document* document : set)
         fprintf(stderr, "- Document %p URL: %s\n", document, document->url().getString().utf8().data());
 }
 #endif