Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/editing/serializers/Serialization.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009, 2010, 2011 Google Inc. All rights reserved.
  * Copyright (C) 2011 Igalia S.L.
  * Copyright (C) 2011 Motorola Mobility. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 61 matching lines @@
 using namespace HTMLNames;
 
 class AttributeChange {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
     AttributeChange()
         : m_name(nullAtom, nullAtom, nullAtom)
     {
     }
 
-    AttributeChange(PassRefPtrWillBeRawPtr<Element> element, const QualifiedName& name, const String& value)
+    AttributeChange(RawPtr<Element> element, const QualifiedName& name, const String& value)
         : m_element(element), m_name(name), m_value(value)
     {
     }
 
     void apply()
     {
         m_element->setAttribute(m_name, AtomicString(m_value));
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(m_element);
     }
 
 private:
-    RefPtrWillBeMember<Element> m_element;
+    Member<Element> m_element;
     QualifiedName m_name;
     String m_value;
 };
 
 } // namespace blink
 
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::AttributeChange);
 
 namespace blink {
 
 static void completeURLs(DocumentFragment& fragment, const String& baseURL)
 {
-    WillBeHeapVector<AttributeChange> changes;
+    HeapVector<AttributeChange> changes;
 
     KURL parsedBaseURL(ParsedURLString, baseURL);
 
     for (Element& element : ElementTraversal::descendantsOf(fragment)) {
         AttributeCollection attributes = element.attributes();
         // AttributeCollection::iterator end = attributes.end();
         for (const auto& attribute : attributes) {
             if (element.isURLAttribute(attribute) && !attribute.value().isEmpty())
                 changes.append(AttributeChange(&element, attribute.name(), KURL(parsedBaseURL, attribute.value()).string()));
         }
@@ skipping 32 matching lines @@
 static inline HTMLElement* ancestorToRetainStructureAndAppearanceWithNoLayoutObject(Node* commonAncestor)
 {
     HTMLElement* commonAncestorBlock = toHTMLElement(enclosingNodeOfType(firstPositionInOrBeforeNode(commonAncestor), isHTMLBlockElement));
     return ancestorToRetainStructureAndAppearanceForBlock(commonAncestorBlock);
 }
 
 bool propertyMissingOrEqualToNone(StylePropertySet* style, CSSPropertyID propertyID)
 {
     if (!style)
         return false;
-    RefPtrWillBeRawPtr<CSSValue> value = style->getPropertyCSSValue(propertyID);
+    RawPtr<CSSValue> value = style->getPropertyCSSValue(propertyID);
     if (!value)
         return true;
     if (!value->isPrimitiveValue())
         return false;
     return toCSSPrimitiveValue(value.get())->getValueID() == CSSValueNone;
 }
 
 static bool isPresentationalHTMLElement(const Node* node)
 {
     if (!node->isHTMLElement())
@@ skipping 90 matching lines @@
 String createMarkup(const Position& startPosition, const Position& endPosition, EAnnotateForInterchange shouldAnnotate, ConvertBlocksToInlines convertBlocksToInlines, EAbsoluteURLs shouldResolveURLs, Node* constrainingAncestor)
 {
     return CreateMarkupAlgorithm<EditingStrategy>::createMarkup(startPosition, endPosition, shouldAnnotate, convertBlocksToInlines, shouldResolveURLs, constrainingAncestor);
 }
 
 String createMarkup(const PositionInFlatTree& startPosition, const PositionInFlatTree& endPosition, EAnnotateForInterchange shouldAnnotate, ConvertBlocksToInlines convertBlocksToInlines, EAbsoluteURLs shouldResolveURLs, Node* constrainingAncestor)
 {
     return CreateMarkupAlgorithm<EditingInFlatTreeStrategy>::createMarkup(startPosition, endPosition, shouldAnnotate, convertBlocksToInlines, shouldResolveURLs, constrainingAncestor);
 }
 
-PassRefPtrWillBeRawPtr<DocumentFragment> createFragmentFromMarkup(Document& document, const String& markup, const String& baseURL, ParserContentPolicy parserContentPolicy)
+RawPtr<DocumentFragment> createFragmentFromMarkup(Document& document, const String& markup, const String& baseURL, ParserContentPolicy parserContentPolicy)
 {
     // We use a fake body element here to trick the HTML parser to using the InBody insertion mode.
-    RefPtrWillBeRawPtr<HTMLBodyElement> fakeBody = HTMLBodyElement::create(document);
-    RefPtrWillBeRawPtr<DocumentFragment> fragment = DocumentFragment::create(document);
+    RawPtr<HTMLBodyElement> fakeBody = HTMLBodyElement::create(document);
+    RawPtr<DocumentFragment> fragment = DocumentFragment::create(document);
 
     fragment->parseHTML(markup, fakeBody.get(), parserContentPolicy);
 
     if (!baseURL.isEmpty() && baseURL != blankURL() && baseURL != document.baseURL())
         completeURLs(*fragment, baseURL);
 
     return fragment.release();
 }
 
 static const char fragmentMarkerTag[] = "webkit-fragment-marker";
 
-static bool findNodesSurroundingContext(DocumentFragment* fragment, RefPtrWillBeRawPtr<Comment>& nodeBeforeContext, RefPtrWillBeRawPtr<Comment>& nodeAfterContext)
+static bool findNodesSurroundingContext(DocumentFragment* fragment, RawPtr<Comment>& nodeBeforeContext, RawPtr<Comment>& nodeAfterContext)
 {
     for (Node& node : NodeTraversal::startsAt(fragment->firstChild())) {
         if (node.nodeType() == Node::COMMENT_NODE && toComment(node).data() == fragmentMarkerTag) {
             if (!nodeBeforeContext) {
                 nodeBeforeContext = &toComment(node);
             } else {
                 nodeAfterContext = &toComment(node);
                 return true;
             }
         }
     }
     return false;
 }
 
 static void trimFragment(DocumentFragment* fragment, Comment* nodeBeforeContext, Comment* nodeAfterContext)
 {
-    RefPtrWillBeRawPtr<Node> next = nullptr;
-    for (RefPtrWillBeRawPtr<Node> node = fragment->firstChild(); node; node = next) {
+    RawPtr<Node> next = nullptr;
+    for (RawPtr<Node> node = fragment->firstChild(); node; node = next) {
         if (nodeBeforeContext->isDescendantOf(node.get())) {
             next = NodeTraversal::next(*node);
             continue;
         }
         next = NodeTraversal::nextSkippingChildren(*node);
         ASSERT(!node->contains(nodeAfterContext));
         node->parentNode()->removeChild(node.get(), ASSERT_NO_EXCEPTION);
         if (nodeBeforeContext == node)
             break;
     }
 
     ASSERT(nodeAfterContext->parentNode());
-    for (RefPtrWillBeRawPtr<Node> node = nodeAfterContext; node; node = next) {
+    for (RawPtr<Node> node = nodeAfterContext; node; node = next) {
         next = NodeTraversal::nextSkippingChildren(*node);
         node->parentNode()->removeChild(node.get(), ASSERT_NO_EXCEPTION);
     }
 }
 
-PassRefPtrWillBeRawPtr<DocumentFragment> createFragmentFromMarkupWithContext(Document& document, const String& markup, unsigned fragmentStart, unsigned fragmentEnd,
+RawPtr<DocumentFragment> createFragmentFromMarkupWithContext(Document& document, const String& markup, unsigned fragmentStart, unsigned fragmentEnd,
     const String& baseURL, ParserContentPolicy parserContentPolicy)
 {
     // FIXME: Need to handle the case where the markup already contains these markers.
 
     StringBuilder taggedMarkup;
     taggedMarkup.append(markup.left(fragmentStart));
     MarkupFormatter::appendComment(taggedMarkup, fragmentMarkerTag);
     taggedMarkup.append(markup.substring(fragmentStart, fragmentEnd - fragmentStart));
     MarkupFormatter::appendComment(taggedMarkup, fragmentMarkerTag);
     taggedMarkup.append(markup.substring(fragmentEnd));
 
-    RefPtrWillBeRawPtr<DocumentFragment> taggedFragment = createFragmentFromMarkup(document, taggedMarkup.toString(), baseURL, parserContentPolicy);
+    RawPtr<DocumentFragment> taggedFragment = createFragmentFromMarkup(document, taggedMarkup.toString(), baseURL, parserContentPolicy);
 
-    RefPtrWillBeRawPtr<Comment> nodeBeforeContext = nullptr;
-    RefPtrWillBeRawPtr<Comment> nodeAfterContext = nullptr;
+    RawPtr<Comment> nodeBeforeContext = nullptr;
+    RawPtr<Comment> nodeAfterContext = nullptr;
     if (!findNodesSurroundingContext(taggedFragment.get(), nodeBeforeContext, nodeAfterContext))
         return nullptr;
 
-    RefPtrWillBeRawPtr<Document> taggedDocument = Document::create();
+    RawPtr<Document> taggedDocument = Document::create();
     taggedDocument->setContextFeatures(document.contextFeatures());
 
-    RefPtrWillBeRawPtr<Element> root = Element::create(QualifiedName::null(), taggedDocument.get());
+    RawPtr<Element> root = Element::create(QualifiedName::null(), taggedDocument.get());
     root->appendChild(taggedFragment.get());
     taggedDocument->appendChild(root);
 
-    RefPtrWillBeRawPtr<Range> range = Range::create(*taggedDocument.get(),
+    RawPtr<Range> range = Range::create(*taggedDocument.get(),
         positionAfterNode(nodeBeforeContext.get()).parentAnchoredEquivalent(),
         positionBeforeNode(nodeAfterContext.get()).parentAnchoredEquivalent());
 
     Node* commonAncestor = range->commonAncestorContainer();
     HTMLElement* specialCommonAncestor = ancestorToRetainStructureAndAppearanceWithNoLayoutObject(commonAncestor);
 
     // When there's a special common ancestor outside of the fragment, we must include it as well to
     // preserve the structure and appearance of the fragment. For example, if the fragment contains
     // TD, we need to include the enclosing TABLE tag as well.
-    RefPtrWillBeRawPtr<DocumentFragment> fragment = DocumentFragment::create(document);
+    RawPtr<DocumentFragment> fragment = DocumentFragment::create(document);
     if (specialCommonAncestor)
         fragment->appendChild(specialCommonAncestor);
     else
         fragment->parserTakeAllChildrenFrom(toContainerNode(*commonAncestor));
 
     trimFragment(fragment.get(), nodeBeforeContext.get(), nodeAfterContext.get());
 
     return fragment;
 }
 
@@ skipping 24 matching lines @@
     size_t numEntries = tabList.size();
     for (size_t i = 0; i < numEntries; ++i) {
         const String& s = tabList[i];
 
         // append the non-tab textual part
         if (!s.isEmpty()) {
             if (!tabText.isEmpty()) {
                 paragraph->appendChild(createTabSpanElement(document, tabText.toString()));
                 tabText.clear();
             }
-            RefPtrWillBeRawPtr<Text> textNode = document.createTextNode(stringWithRebalancedWhitespace(s, first, i + 1 == numEntries));
+            RawPtr<Text> textNode = document.createTextNode(stringWithRebalancedWhitespace(s, first, i + 1 == numEntries));
             paragraph->appendChild(textNode.release());
         }
 
         // there is a tab after every entry, except the last entry
         // (if the last character is a tab, the list gets an extra empty entry)
         if (i + 1 != numEntries)
             tabText.append('\t');
         else if (!tabText.isEmpty())
             paragraph->appendChild(createTabSpanElement(document, tabText.toString()));
 
@@ skipping 25 matching lines @@
     }
 
     if (Node* node = range.startPosition().anchorNode()) {
         if (LayoutObject* layoutObject = node->layoutObject())
             return layoutObject->style()->preserveNewline();
     }
 
     return false;
 }
 
-PassRefPtrWillBeRawPtr<DocumentFragment> createFragmentFromText(const EphemeralRange& context, const String& text)
+RawPtr<DocumentFragment> createFragmentFromText(const EphemeralRange& context, const String& text)
 {
     if (context.isNull())
         return nullptr;
 
     Document& document = context.document();
-    RefPtrWillBeRawPtr<DocumentFragment> fragment = document.createDocumentFragment();
+    RawPtr<DocumentFragment> fragment = document.createDocumentFragment();
 
     if (text.isEmpty())
         return fragment.release();
 
     String string = text;
     string.replace("\r\n", "\n");
     string.replace('\r', '\n');
 
     if (shouldPreserveNewline(context)) {
         fragment->appendChild(document.createTextNode(string));
         if (string.endsWith('\n')) {
-            RefPtrWillBeRawPtr<HTMLBRElement> element = HTMLBRElement::create(document);
+            RawPtr<HTMLBRElement> element = HTMLBRElement::create(document);
             element->setAttribute(classAttr, AppleInterchangeNewline);
             fragment->appendChild(element.release());
         }
         return fragment.release();
     }
 
     // A string with no newlines gets added inline, rather than being put into a paragraph.
     if (string.find('\n') == kNotFound) {
         fillContainerFromString(fragment.get(), string);
         return fragment.release();
     }
 
     // Break string into paragraphs. Extra line breaks turn into empty paragraphs.
     Element* block = enclosingBlock(context.startPosition().nodeAsRangeFirstNode());
     bool useClonesOfEnclosingBlock = block
         && !isHTMLBodyElement(*block)
         && !isHTMLHtmlElement(*block)
         && block != rootEditableElementOf(context.startPosition());
     bool useLineBreak = enclosingTextFormControl(context.startPosition());
 
     Vector<String> list;
     string.split('\n', true, list); // true gets us empty strings in the list
     size_t numLines = list.size();
     for (size_t i = 0; i < numLines; ++i) {
         const String& s = list[i];
 
-        RefPtrWillBeRawPtr<Element> element = nullptr;
+        RawPtr<Element> element = nullptr;
         if (s.isEmpty() && i + 1 == numLines) {
             // For last line, use the "magic BR" rather than a P.
             element = HTMLBRElement::create(document);
             element->setAttribute(classAttr, AppleInterchangeNewline);
         } else if (useLineBreak) {
             element = HTMLBRElement::create(document);
             fillContainerFromString(fragment.get(), s);
         } else {
             if (useClonesOfEnclosingBlock)
                 element = block->cloneElementWithoutChildren();
@@ skipping 10 matching lines @@
 {
     StringBuilder markup;
     markup.appendLiteral("<a href=\"");
     markup.append(url.string());
     markup.appendLiteral("\">");
     MarkupFormatter::appendCharactersReplacingEntities(markup, title, 0, title.length(), EntityMaskInPCDATA);
     markup.appendLiteral("</a>");
     return markup.toString();
 }
 
-PassRefPtrWillBeRawPtr<DocumentFragment> createFragmentForInnerOuterHTML(const String& markup, Element* contextElement, ParserContentPolicy parserContentPolicy, const char* method, ExceptionState& exceptionState)
+RawPtr<DocumentFragment> createFragmentForInnerOuterHTML(const String& markup, Element* contextElement, ParserContentPolicy parserContentPolicy, const char* method, ExceptionState& exceptionState)
 {
     ASSERT(contextElement);
     Document& document = isHTMLTemplateElement(*contextElement) ? contextElement->document().ensureTemplateDocument() : contextElement->document();
-    RefPtrWillBeRawPtr<DocumentFragment> fragment = DocumentFragment::create(document);
+    RawPtr<DocumentFragment> fragment = DocumentFragment::create(document);
 
     if (document.isHTMLDocument()) {
         fragment->parseHTML(markup, contextElement, parserContentPolicy);
         return fragment;
     }
 
     bool wasValid = fragment->parseXML(markup, contextElement, parserContentPolicy);
     if (!wasValid) {
         exceptionState.throwDOMException(SyntaxError, "The provided markup is invalid XML, and therefore cannot be inserted into an XML document.");
         return nullptr;
     }
     return fragment.release();
 }
 
-PassRefPtrWillBeRawPtr<DocumentFragment> createFragmentForTransformToFragment(const String& sourceString, const String& sourceMIMEType, Document& outputDoc)
+RawPtr<DocumentFragment> createFragmentForTransformToFragment(const String& sourceString, const String& sourceMIMEType, Document& outputDoc)
 {
-    RefPtrWillBeRawPtr<DocumentFragment> fragment = outputDoc.createDocumentFragment();
+    RawPtr<DocumentFragment> fragment = outputDoc.createDocumentFragment();
 
     if (sourceMIMEType == "text/html") {
         // As far as I can tell, there isn't a spec for how transformToFragment is supposed to work.
         // Based on the documentation I can find, it looks like we want to start parsing the fragment in the InBody insertion mode.
         // Unfortunately, that's an implementation detail of the parser.
         // We achieve that effect here by passing in a fake body element as context for the fragment.
-        RefPtrWillBeRawPtr<HTMLBodyElement> fakeBody = HTMLBodyElement::create(outputDoc);
+        RawPtr<HTMLBodyElement> fakeBody = HTMLBodyElement::create(outputDoc);
         fragment->parseHTML(sourceString, fakeBody.get());
     } else if (sourceMIMEType == "text/plain") {
         fragment->parserAppendChild(Text::create(outputDoc, sourceString));
     } else {
         bool successfulParse = fragment->parseXML(sourceString, 0);
         if (!successfulParse)
             return nullptr;
     }
 
     // FIXME: Do we need to mess with URLs here?
 
     return fragment.release();
 }
 
-static inline void removeElementPreservingChildren(PassRefPtrWillBeRawPtr<DocumentFragment> fragment, HTMLElement* element)
+static inline void removeElementPreservingChildren(RawPtr<DocumentFragment> fragment, HTMLElement* element)
 {
-    RefPtrWillBeRawPtr<Node> nextChild = nullptr;
-    for (RefPtrWillBeRawPtr<Node> child = element->firstChild(); child; child = nextChild) {
+    RawPtr<Node> nextChild = nullptr;
+    for (RawPtr<Node> child = element->firstChild(); child; child = nextChild) {
         nextChild = child->nextSibling();
         element->removeChild(child.get());
         fragment->insertBefore(child, element);
     }
     fragment->removeChild(element);
 }
 
 static inline bool isSupportedContainer(Element* element)
 {
     ASSERT(element);
     if (!element->isHTMLElement())
         return true;
 
     HTMLElement& htmlElement = toHTMLElement(*element);
     if (htmlElement.hasTagName(colTag) || htmlElement.hasTagName(colgroupTag) || htmlElement.hasTagName(framesetTag)
         || htmlElement.hasTagName(headTag) || htmlElement.hasTagName(styleTag) || htmlElement.hasTagName(titleTag)) {
         return false;
     }
     return !htmlElement.ieForbidsInsertHTML();
 }
 
-PassRefPtrWillBeRawPtr<DocumentFragment> createContextualFragment(const String& markup, Element* element, ParserContentPolicy parserContentPolicy, ExceptionState& exceptionState)
+RawPtr<DocumentFragment> createContextualFragment(const String& markup, Element* element, ParserContentPolicy parserContentPolicy, ExceptionState& exceptionState)
 {
     ASSERT(element);
     if (!isSupportedContainer(element)) {
         exceptionState.throwDOMException(NotSupportedError, "The range's container is '" + element->localName() + "', which is not supported.");
         return nullptr;
     }
 
-    RefPtrWillBeRawPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(markup, element, parserContentPolicy, "createContextualFragment", exceptionState);
+    RawPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(markup, element, parserContentPolicy, "createContextualFragment", exceptionState);
     if (!fragment)
         return nullptr;
 
     // We need to pop <html> and <body> elements and remove <head> to
     // accommodate folks passing complete HTML documents to make the
     // child of an element.
 
-    RefPtrWillBeRawPtr<Node> nextNode = nullptr;
-    for (RefPtrWillBeRawPtr<Node> node = fragment->firstChild(); node; node = nextNode) {
+    RawPtr<Node> nextNode = nullptr;
+    for (RawPtr<Node> node = fragment->firstChild(); node; node = nextNode) {
         nextNode = node->nextSibling();
         if (isHTMLHtmlElement(*node) || isHTMLHeadElement(*node) || isHTMLBodyElement(*node)) {
             HTMLElement* element = toHTMLElement(node);
             if (Node* firstChild = element->firstChild())
                 nextNode = firstChild;
             removeElementPreservingChildren(fragment, element);
         }
     }
     return fragment.release();
 }
 
-void replaceChildrenWithFragment(ContainerNode* container, PassRefPtrWillBeRawPtr<DocumentFragment> fragment, ExceptionState& exceptionState)
+void replaceChildrenWithFragment(ContainerNode* container, RawPtr<DocumentFragment> fragment, ExceptionState& exceptionState)
 {
     ASSERT(container);
-    RefPtrWillBeRawPtr<ContainerNode> containerNode(container);
+    RawPtr<ContainerNode> containerNode(container);
 
     ChildListMutationScope mutation(*containerNode);
 
     if (!fragment->firstChild()) {
         containerNode->removeChildren();
         return;
     }
 
     // FIXME: This is wrong if containerNode->firstChild() has more than one ref!
     if (containerNode->hasOneTextChild() && fragment->hasOneTextChild()) {
         toText(containerNode->firstChild())->setData(toText(fragment->firstChild())->data());
         return;
     }
 
     // FIXME: No need to replace the child it is a text node and its contents are already == text.
     if (containerNode->hasOneChild()) {
         containerNode->replaceChild(fragment, containerNode->firstChild(), exceptionState);
         return;
     }
 
     containerNode->removeChildren();
     containerNode->appendChild(fragment, exceptionState);
 }
 
 void replaceChildrenWithText(ContainerNode* container, const String& text, ExceptionState& exceptionState)
 {
     ASSERT(container);
-    RefPtrWillBeRawPtr<ContainerNode> containerNode(container);
+    RawPtr<ContainerNode> containerNode(container);
 
     ChildListMutationScope mutation(*containerNode);
 
     // FIXME: This is wrong if containerNode->firstChild() has more than one ref! Example:
     // <div>foo</div>
     // <script>
     // var oldText = div.firstChild;
     // console.log(oldText.data); // foo
     // div.innerText = "bar";
     // console.log(oldText.data); // bar!?!
     // </script>
     // I believe this is an intentional benchmark cheat from years ago.
     // We should re-visit if we actually want this still.
     if (containerNode->hasOneTextChild()) {
         toText(containerNode->firstChild())->setData(text);
         return;
     }
 
     // NOTE: This method currently always creates a text node, even if that text node will be empty.
-    RefPtrWillBeRawPtr<Text> textNode = Text::create(containerNode->document(), text);
+    RawPtr<Text> textNode = Text::create(containerNode->document(), text);
 
     // FIXME: No need to replace the child it is a text node and its contents are already == text.
     if (containerNode->hasOneChild()) {
         containerNode->replaceChild(textNode.release(), containerNode->firstChild(), exceptionState);
         return;
     }
 
     containerNode->removeChildren();
     containerNode->appendChild(textNode.release(), exceptionState);
 }
 
 void mergeWithNextTextNode(Text* textNode, ExceptionState& exceptionState)
 {
     ASSERT(textNode);
     Node* next = textNode->nextSibling();
     if (!next || !next->isTextNode())
         return;
 
-    RefPtrWillBeRawPtr<Text> textNext = toText(next);
+    RawPtr<Text> textNext = toText(next);
     textNode->appendData(textNext->data());
     if (textNext->parentNode()) // Might have been removed by mutation event.
         textNext->remove(exceptionState);
 }
 
 template class CORE_TEMPLATE_EXPORT CreateMarkupAlgorithm<EditingStrategy>;
 template class CORE_TEMPLATE_EXPORT CreateMarkupAlgorithm<EditingInFlatTreeStrategy>;
 
 } // namespace blink