Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/html/HTMLTableElement.cpp

 /*
  * Copyright (C) 1997 Martin Jones (mjones@kde.org)
  *           (C) 1997 Torben Weis (weis@kde.org)
  *           (C) 1998 Waldo Bastian (bastian@kde.org)
  *           (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2010, 2011 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 57 matching lines @@
 {
 }
 
 DEFINE_NODE_FACTORY(HTMLTableElement)
 
 HTMLTableCaptionElement* HTMLTableElement::caption() const
 {
     return Traversal<HTMLTableCaptionElement>::firstChild(*this);
 }
 
-void HTMLTableElement::setCaption(PassRefPtrWillBeRawPtr<HTMLTableCaptionElement> newCaption, ExceptionState& exceptionState)
+void HTMLTableElement::setCaption(RawPtr<HTMLTableCaptionElement> newCaption, ExceptionState& exceptionState)
 {
     deleteCaption();
     insertBefore(newCaption, firstChild(), exceptionState);
 }
 
 HTMLTableSectionElement* HTMLTableElement::tHead() const
 {
     return toHTMLTableSectionElement(Traversal<HTMLElement>::firstChild(*this, HasHTMLTagName(theadTag)));
 }
 
-void HTMLTableElement::setTHead(PassRefPtrWillBeRawPtr<HTMLTableSectionElement> newHead, ExceptionState& exceptionState)
+void HTMLTableElement::setTHead(RawPtr<HTMLTableSectionElement> newHead, ExceptionState& exceptionState)
 {
     deleteTHead();
 
     HTMLElement* child;
     for (child = Traversal<HTMLElement>::firstChild(*this); child; child = Traversal<HTMLElement>::nextSibling(*child)) {
         if (!child->hasTagName(captionTag) && !child->hasTagName(colgroupTag))
             break;
     }
 
     insertBefore(newHead, child, exceptionState);
 }
 
 HTMLTableSectionElement* HTMLTableElement::tFoot() const
 {
     return toHTMLTableSectionElement(Traversal<HTMLElement>::firstChild(*this, HasHTMLTagName(tfootTag)));
 }
 
-void HTMLTableElement::setTFoot(PassRefPtrWillBeRawPtr<HTMLTableSectionElement> newFoot, ExceptionState& exceptionState)
+void HTMLTableElement::setTFoot(RawPtr<HTMLTableSectionElement> newFoot, ExceptionState& exceptionState)
 {
     deleteTFoot();
 
     HTMLElement* child;
     for (child = Traversal<HTMLElement>::firstChild(*this); child; child = Traversal<HTMLElement>::nextSibling(*child)) {
         if (!child->hasTagName(captionTag) && !child->hasTagName(colgroupTag) && !child->hasTagName(theadTag))
             break;
     }
 
     insertBefore(newFoot, child, exceptionState);
 }
 
-PassRefPtrWillBeRawPtr<HTMLTableSectionElement> HTMLTableElement::createTHead()
+RawPtr<HTMLTableSectionElement> HTMLTableElement::createTHead()
 {
     if (HTMLTableSectionElement* existingHead = tHead())
         return existingHead;
-    RefPtrWillBeRawPtr<HTMLTableSectionElement> head = HTMLTableSectionElement::create(theadTag, document());
+    RawPtr<HTMLTableSectionElement> head = HTMLTableSectionElement::create(theadTag, document());
     setTHead(head, IGNORE_EXCEPTION);
     return head.release();
 }
 
 void HTMLTableElement::deleteTHead()
 {
     removeChild(tHead(), IGNORE_EXCEPTION);
 }
 
-PassRefPtrWillBeRawPtr<HTMLTableSectionElement> HTMLTableElement::createTFoot()
+RawPtr<HTMLTableSectionElement> HTMLTableElement::createTFoot()
 {
     if (HTMLTableSectionElement* existingFoot = tFoot())
         return existingFoot;
-    RefPtrWillBeRawPtr<HTMLTableSectionElement> foot = HTMLTableSectionElement::create(tfootTag, document());
+    RawPtr<HTMLTableSectionElement> foot = HTMLTableSectionElement::create(tfootTag, document());
     setTFoot(foot, IGNORE_EXCEPTION);
     return foot.release();
 }
 
 void HTMLTableElement::deleteTFoot()
 {
     removeChild(tFoot(), IGNORE_EXCEPTION);
 }
 
-PassRefPtrWillBeRawPtr<HTMLTableSectionElement> HTMLTableElement::createTBody()
+RawPtr<HTMLTableSectionElement> HTMLTableElement::createTBody()
 {
-    RefPtrWillBeRawPtr<HTMLTableSectionElement> body = HTMLTableSectionElement::create(tbodyTag, document());
+    RawPtr<HTMLTableSectionElement> body = HTMLTableSectionElement::create(tbodyTag, document());
     Node* referenceElement = lastBody() ? lastBody()->nextSibling() : 0;
 
     insertBefore(body, referenceElement);
     return body.release();
 }
 
-PassRefPtrWillBeRawPtr<HTMLTableCaptionElement> HTMLTableElement::createCaption()
+RawPtr<HTMLTableCaptionElement> HTMLTableElement::createCaption()
 {
     if (HTMLTableCaptionElement* existingCaption = caption())
         return existingCaption;
-    RefPtrWillBeRawPtr<HTMLTableCaptionElement> caption = HTMLTableCaptionElement::create(document());
+    RawPtr<HTMLTableCaptionElement> caption = HTMLTableCaptionElement::create(document());
     setCaption(caption, IGNORE_EXCEPTION);
     return caption.release();
 }
 
 void HTMLTableElement::deleteCaption()
 {
     removeChild(caption(), IGNORE_EXCEPTION);
 }
 
 HTMLTableSectionElement* HTMLTableElement::lastBody() const
 {
     return toHTMLTableSectionElement(Traversal<HTMLElement>::lastChild(*this, HasHTMLTagName(tbodyTag)));
 }
 
-PassRefPtrWillBeRawPtr<HTMLTableRowElement> HTMLTableElement::insertRow(int index, ExceptionState& exceptionState)
+RawPtr<HTMLTableRowElement> HTMLTableElement::insertRow(int index, ExceptionState& exceptionState)
 {
     if (index < -1) {
         exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is less than -1.");
         return nullptr;
     }
 
-    RefPtrWillBeRawPtr<Node> protectFromMutationEvents(this);
+    RawPtr<Node> protectFromMutationEvents(this);
 
-    RefPtrWillBeRawPtr<HTMLTableRowElement> lastRow = nullptr;
-    RefPtrWillBeRawPtr<HTMLTableRowElement> row = nullptr;
+    RawPtr<HTMLTableRowElement> lastRow = nullptr;
+    RawPtr<HTMLTableRowElement> row = nullptr;
     if (index == -1) {
         lastRow = HTMLTableRowsCollection::lastRow(*this);
     } else {
         for (int i = 0; i <= index; ++i) {
             row = HTMLTableRowsCollection::rowAfter(*this, lastRow.get());
             if (!row) {
                 if (i != index) {
                     exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is greater than the number of rows in the table (" + String::number(i) + ").");
                     return nullptr;
                 }
                 break;
             }
             lastRow = row;
         }
     }
 
-    RefPtrWillBeRawPtr<ContainerNode> parent;
+    RawPtr<ContainerNode> parent;
     if (lastRow) {
         parent = row ? row->parentNode() : lastRow->parentNode();
     } else {
         parent = lastBody();
         if (!parent) {
-            RefPtrWillBeRawPtr<HTMLTableSectionElement> newBody = HTMLTableSectionElement::create(tbodyTag, document());
-            RefPtrWillBeRawPtr<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
+            RawPtr<HTMLTableSectionElement> newBody = HTMLTableSectionElement::create(tbodyTag, document());
+            RawPtr<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
             newBody->appendChild(newRow, exceptionState);
             appendChild(newBody.release(), exceptionState);
             return newRow.release();
         }
     }
 
-    RefPtrWillBeRawPtr<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
+    RawPtr<HTMLTableRowElement> newRow = HTMLTableRowElement::create(document());
     parent->insertBefore(newRow, row.get(), exceptionState);
     return newRow.release();
 }
 
 void HTMLTableElement::deleteRow(int index, ExceptionState& exceptionState)
 {
     if (index < -1) {
         exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is less than -1.");
         return;
     }
@@ skipping 63 matching lines @@
     } else if (name == borderAttr) {
         addPropertyToPresentationAttributeStyle(style, CSSPropertyBorderWidth, parseBorderWidthAttribute(value), CSSPrimitiveValue::UnitType::Pixels);
     } else if (name == bordercolorAttr) {
         if (!value.isEmpty())
             addHTMLColorToStyle(style, CSSPropertyBorderColor, value);
     } else if (name == bgcolorAttr) {
         addHTMLColorToStyle(style, CSSPropertyBackgroundColor, value);
     } else if (name == backgroundAttr) {
         String url = stripLeadingAndTrailingHTMLSpaces(value);
         if (!url.isEmpty()) {
-            RefPtrWillBeRawPtr<CSSImageValue> imageValue = CSSImageValue::create(url, document().completeURL(url));
+            RawPtr<CSSImageValue> imageValue = CSSImageValue::create(url, document().completeURL(url));
             imageValue->setReferrer(Referrer(document().outgoingReferrer(), document().getReferrerPolicy()));
             style->setProperty(CSSProperty(CSSPropertyBackgroundImage, imageValue.release()));
         }
     } else if (name == valignAttr) {
         if (!value.isEmpty())
             addPropertyToPresentationAttributeStyle(style, CSSPropertyVerticalAlign, value);
     } else if (name == cellspacingAttr) {
         if (!value.isEmpty())
             addHTMLLengthToStyle(style, CSSPropertyBorderSpacing, value);
     } else if (name == alignAttr) {
@@ skipping 72 matching lines @@
     } else {
         HTMLElement::parseAttribute(name, oldValue, value);
     }
 
     if (bordersBefore != getCellBorders() || oldPadding != m_padding) {
         m_sharedCellStyle = nullptr;
         setNeedsTableStyleRecalc();
     }
 }
 
-static PassRefPtrWillBeRawPtr<StylePropertySet> createBorderStyle(CSSValueID value)
+static RawPtr<StylePropertySet> createBorderStyle(CSSValueID value)
 {
-    RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create(HTMLQuirksMode);
+    RawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create(HTMLQuirksMode);
     style->setProperty(CSSPropertyBorderTopStyle, value);
     style->setProperty(CSSPropertyBorderBottomStyle, value);
     style->setProperty(CSSPropertyBorderLeftStyle, value);
     style->setProperty(CSSPropertyBorderRightStyle, value);
     return style.release();
 }
 
 const StylePropertySet* HTMLTableElement::additionalPresentationAttributeStyle()
 {
     if (m_frameAttr)
@@ skipping 33 matching lines @@
         if (!m_borderAttr)
             return NoBorders;
         if (m_borderColorAttr)
             return SolidBorders;
         return InsetBorders;
     }
     ASSERT_NOT_REACHED();
     return NoBorders;
 }
 
-PassRefPtrWillBeRawPtr<StylePropertySet> HTMLTableElement::createSharedCellStyle()
+RawPtr<StylePropertySet> HTMLTableElement::createSharedCellStyle()
 {
-    RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create(HTMLQuirksMode);
+    RawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create(HTMLQuirksMode);
 
     switch (getCellBorders()) {
     case SolidBordersColsOnly:
         style->setProperty(CSSPropertyBorderLeftWidth, CSSValueThin);
         style->setProperty(CSSPropertyBorderRightWidth, CSSValueThin);
         style->setProperty(CSSPropertyBorderLeftStyle, CSSValueSolid);
         style->setProperty(CSSPropertyBorderRightStyle, CSSValueSolid);
         style->setProperty(CSSPropertyBorderColor, cssValuePool().createInheritedValue());
         break;
     case SolidBordersRowsOnly:
@@ skipping 24 matching lines @@
     return style.release();
 }
 
 const StylePropertySet* HTMLTableElement::additionalCellStyle()
 {
     if (!m_sharedCellStyle)
         m_sharedCellStyle = createSharedCellStyle();
     return m_sharedCellStyle.get();
 }
 
-static PassRefPtrWillBeRawPtr<StylePropertySet> createGroupBorderStyle(int rows)
+static RawPtr<StylePropertySet> createGroupBorderStyle(int rows)
 {
-    RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create(HTMLQuirksMode);
+    RawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create(HTMLQuirksMode);
     if (rows) {
         style->setProperty(CSSPropertyBorderTopWidth, CSSValueThin);
         style->setProperty(CSSPropertyBorderBottomWidth, CSSValueThin);
         style->setProperty(CSSPropertyBorderTopStyle, CSSValueSolid);
         style->setProperty(CSSPropertyBorderBottomStyle, CSSValueSolid);
     } else {
         style->setProperty(CSSPropertyBorderLeftWidth, CSSValueThin);
         style->setProperty(CSSPropertyBorderRightWidth, CSSValueThin);
         style->setProperty(CSSPropertyBorderLeftStyle, CSSValueSolid);
         style->setProperty(CSSPropertyBorderRightStyle, CSSValueSolid);
@@ skipping 22 matching lines @@
 bool HTMLTableElement::hasLegalLinkAttribute(const QualifiedName& name) const
 {
     return name == backgroundAttr || HTMLElement::hasLegalLinkAttribute(name);
 }
 
 const QualifiedName& HTMLTableElement::subResourceAttributeName() const
 {
     return backgroundAttr;
 }
 
-PassRefPtrWillBeRawPtr<HTMLTableRowsCollection> HTMLTableElement::rows()
+RawPtr<HTMLTableRowsCollection> HTMLTableElement::rows()
 {
     return ensureCachedCollection<HTMLTableRowsCollection>(TableRows);
 }
 
-PassRefPtrWillBeRawPtr<HTMLCollection> HTMLTableElement::tBodies()
+RawPtr<HTMLCollection> HTMLTableElement::tBodies()
 {
     return ensureCachedCollection<HTMLCollection>(TableTBodies);
 }
 
 const AtomicString& HTMLTableElement::rules() const
 {
     return getAttribute(rulesAttr);
 }
 
 const AtomicString& HTMLTableElement::summary() const
 {
     return getAttribute(summaryAttr);
 }
 
 DEFINE_TRACE(HTMLTableElement)
 {
     visitor->trace(m_sharedCellStyle);
     HTMLElement::trace(visitor);
 }
 
 } // namespace blink