Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/xml/parser/XMLDocumentParser.cpp

 /*
  * Copyright (C) 2000 Peter Kelly (pmk@post.com)
  * Copyright (C) 2005, 2006, 2008, 2014 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2008 Holger Hans Peter Freyther
  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 356 matching lines @@
     if (isStopped() || m_sawXSLTransform)
         return;
 
     if (m_parserPaused) {
         m_pendingSrc.append(source);
         return;
     }
 
     // JavaScript can detach the parser. Make sure this is not released
     // before the end of this method.
-    RefPtrWillBeRawPtr<XMLDocumentParser> protect(this);
+    RawPtr<XMLDocumentParser> protect(this);
 
     doWrite(source.toString());
 }
 
 void XMLDocumentParser::handleError(XMLErrors::ErrorType type, const char* formattedMessage, TextPosition position)
 {
     m_xmlErrors.handleError(type, formattedMessage, position);
     if (type != XMLErrors::ErrorTypeWarning)
         m_sawError = true;
     if (type == XMLErrors::ErrorTypeFatal)
@@ skipping 70 matching lines @@
     document()->finishedParsing();
 }
 
 void XMLDocumentParser::finish()
 {
     // FIXME: We should ASSERT(!m_parserStopped) here, since it does not
     // makes sense to call any methods on DocumentParser once it's been stopped.
     // However, FrameLoader::stop calls DocumentParser::finish unconditionally.
 
     // flush may ending up executing arbitrary script, and possibly detach the parser.
-    RefPtrWillBeRawPtr<XMLDocumentParser> protect(this);
+    RawPtr<XMLDocumentParser> protect(this);
     flush();
     if (isDetached())
         return;
 
     if (m_parserPaused)
         m_finishCalled = true;
     else
         end();
 }
 
 void XMLDocumentParser::insertErrorMessageBlock()
 {
     m_xmlErrors.insertErrorMessageBlock();
 }
 
 void XMLDocumentParser::notifyFinished(Resource* unusedResource)
 {
     ASSERT_UNUSED(unusedResource, unusedResource == m_pendingScript);
 
     ScriptSourceCode sourceCode(m_pendingScript.get());
     bool errorOccurred = m_pendingScript->errorOccurred();
     bool wasCanceled = m_pendingScript->wasCanceled();
 
     m_pendingScript->removeClient(this);
     m_pendingScript = nullptr;
 
-    RefPtrWillBeRawPtr<Element> e = m_scriptElement;
+    RawPtr<Element> e = m_scriptElement;
     m_scriptElement = nullptr;
 
     ScriptLoader* scriptLoader = toScriptLoaderIfPossible(e.get());
     ASSERT(scriptLoader);
 
     // JavaScript can detach this parser, make sure it's kept alive even if
     // detached.
-    RefPtrWillBeRawPtr<XMLDocumentParser> protect(this);
+    RawPtr<XMLDocumentParser> protect(this);
 
     if (errorOccurred) {
         scriptLoader->dispatchErrorEvent();
     } else if (!wasCanceled) {
         if (!scriptLoader->executeScript(sourceCode))
             scriptLoader->dispatchErrorEvent();
         else
             scriptLoader->dispatchLoadEvent();
     }
 
@@ skipping 20 matching lines @@
         return true;
 
     // FIXME: We need to implement the HTML5 XML Fragment parsing algorithm:
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-xhtml-syntax.html#xml-fragment-parsing-algorithm
     // For now we have a hack for script/style innerHTML support:
     if (contextElement && (contextElement->hasLocalName(scriptTag.localName()) || contextElement->hasLocalName(styleTag.localName()))) {
         fragment->parserAppendChild(fragment->document().createTextNode(chunk));
         return true;
     }
 
-    RefPtrWillBeRawPtr<XMLDocumentParser> parser = XMLDocumentParser::create(fragment, contextElement, parserContentPolicy);
+    RawPtr<XMLDocumentParser> parser = XMLDocumentParser::create(fragment, contextElement, parserContentPolicy);
     bool wellFormed = parser->appendFragmentSource(chunk);
 
     // Do not call finish(). Current finish() and doEnd() implementations touch
     // the main Document/loader and can cause crashes in the fragment case.
 
     // Allows ~DocumentParser to assert it was detached before destruction.
     parser->detach();
     // appendFragmentSource()'s wellFormed is more permissive than wellFormed().
     return wellFormed;
 }
@@ skipping 115 matching lines @@
         return &globalDescriptor;
 
     KURL finalURL;
     RefPtr<SharedBuffer> data;
 
     {
         Document* document = XMLDocumentParserScope::currentDocument;
         XMLDocumentParserScope scope(0);
         // FIXME: We should restore the original global error handler as well.
         FetchRequest request(ResourceRequest(url), FetchInitiatorTypeNames::xml, ResourceFetcher::defaultResourceOptions());
-        RefPtrWillBeRawPtr<Resource> resource = RawResource::fetchSynchronously(request, document->fetcher());
+        RawPtr<Resource> resource = RawResource::fetchSynchronously(request, document->fetcher());
         if (resource && !resource->errorOccurred()) {
             data = resource->resourceBuffer();
             finalURL = resource->response().url();
         }
     }
 
     // We have to check the URL again after the load to catch redirects.
     // See <https://bugs.webkit.org/show_bug.cgi?id=21963>.
     if (!shouldAllowExternalLoad(finalURL))
         return &globalDescriptor;
@@ skipping 139 matching lines @@
     , m_finishCalled(false)
     , m_xmlErrors(&fragment->document())
     , m_scriptStartPosition(TextPosition::belowRangePosition())
     , m_parsingFragment(true)
 {
 #if !ENABLE(OILPAN)
     fragment->ref();
 #endif
 
     // Add namespaces based on the parent node
-    WillBeHeapVector<RawPtrWillBeMember<Element>> elemStack;
+    HeapVector<Member<Element>> elemStack;
     while (parentElement) {
         elemStack.append(parentElement);
 
         Element* grandParentElement = parentElement->parentElement();
         if (!grandParentElement)
             break;
         parentElement = grandParentElement;
     }
 
     if (elemStack.isEmpty())
@@ skipping 53 matching lines @@
         initializeParserContext();
 
     // Protect the libxml context from deletion during a callback
     RefPtr<XMLParserContext> context = m_context;
 
     // libXML throws an error if you try to switch the encoding for an empty
     // string.
     if (parseString.length()) {
         // JavaScript may cause the parser to detach during parseChunk
         // keep this alive until this function is done.
-        RefPtrWillBeRawPtr<XMLDocumentParser> protect(this);
+        RawPtr<XMLDocumentParser> protect(this);
 
         XMLDocumentParserScope scope(document());
         TemporaryChange<bool> encodingScope(m_isCurrentlyParsing8BitChunk, parseString.is8Bit());
         parseChunk(context->context(), parseString);
 
         // JavaScript (which may be run under the parseChunk callstack) may
         // cause the parser to be stopped or detached.
         if (isStopped())
             return;
     }
@@ skipping 93 matching lines @@
         if (!prefix.isNull())
             adjustedURI = m_prefixToNamespaceMap.get(prefix);
         else
             adjustedURI = m_defaultNamespaceURI;
     }
 
     bool isFirstElement = !m_sawFirstElement;
     m_sawFirstElement = true;
 
     QualifiedName qName(prefix, localName, adjustedURI);
-    RefPtrWillBeRawPtr<Element> newElement = m_currentNode->document().createElement(qName, true);
+    RawPtr<Element> newElement = m_currentNode->document().createElement(qName, true);
     if (!newElement) {
         stopParsing();
         return;
     }
 
     Vector<Attribute> prefixedAttributes;
     TrackExceptionState exceptionState;
     handleNamespaceAttributes(prefixedAttributes, libxmlNamespaces, nbNamespaces, exceptionState);
     if (exceptionState.hadException()) {
         setAttributes(newElement.get(), prefixedAttributes, parserContentPolicy());
@@ skipping 40 matching lines @@
     if (isStopped())
         return;
 
     if (m_parserPaused) {
         m_pendingCallbacks.append(adoptPtr(new PendingEndElementNSCallback(m_scriptStartPosition)));
         return;
     }
 
     // JavaScript can detach the parser. Make sure this is not released before
     // the end of this method.
-    RefPtrWillBeRawPtr<XMLDocumentParser> protect(this);
+    RawPtr<XMLDocumentParser> protect(this);
 
     if (!updateLeafTextNode())
         return;
 
-    RefPtrWillBeRawPtr<ContainerNode> n = m_currentNode;
+    RawPtr<ContainerNode> n = m_currentNode;
     if (m_currentNode->isElementNode())
         toElement(n.get())->finishParsingChildren();
 
     if (!scriptingContentIsAllowed(parserContentPolicy()) && n->isElementNode() && toScriptLoaderIfPossible(toElement(n))) {
         popCurrentNode();
         n->remove(IGNORE_EXCEPTION);
         return;
     }
 
     if (!n->isElementNode() || !m_hasView) {
@@ skipping 93 matching lines @@
     if (m_parserPaused) {
         m_pendingCallbacks.append(adoptPtr(new PendingProcessingInstructionCallback(target, data)));
         return;
     }
 
     if (!updateLeafTextNode())
         return;
 
     // ### handle exceptions
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<ProcessingInstruction> pi = m_currentNode->document().createProcessingInstruction(target, data, exceptionState);
+    RawPtr<ProcessingInstruction> pi = m_currentNode->document().createProcessingInstruction(target, data, exceptionState);
     if (exceptionState.hadException())
         return;
 
     pi->setCreatedByParser(true);
 
     m_currentNode->parserAppendChild(pi.get());
 
     pi->setCreatedByParser(false);
 
     if (pi->isCSS())
@@ skipping 479 matching lines @@
     sax.initialized = XML_SAX2_MAGIC;
     RefPtr<XMLParserContext> parser = XMLParserContext::createStringParser(&sax, &state);
     String parseString = "<?xml version=\"1.0\"?><attrs " + string + " />";
     parseChunk(parser->context(), parseString);
     finishParsing(parser->context());
     attrsOK = state.gotAttributes;
     return state.attributes;
 }
 
 } // namespace blink