Oilpan: Remove most WillBe types from the code base

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

Index: third_party/WebKit/Source/core/editing/serializers/StyledMarkupSerializer.cpp
diff --git a/third_party/WebKit/Source/core/editing/serializers/StyledMarkupSerializer.cpp b/third_party/WebKit/Source/core/editing/serializers/StyledMarkupSerializer.cpp
index 8e931d63b50f848f278c0d5a4e3f5f7e8c29016e..fe31d233bec1f94448f0a964dabb4fa771fc5bb1 100644
--- a/third_party/WebKit/Source/core/editing/serializers/StyledMarkupSerializer.cpp
+++ b/third_party/WebKit/Source/core/editing/serializers/StyledMarkupSerializer.cpp
@@ -92,21 +92,21 @@ public:
     StyledMarkupTraverser(StyledMarkupAccumulator*, Node*);
 
     Node* traverse(Node*, Node*);
-    void wrapWithNode(ContainerNode&, PassRefPtrWillBeRawPtr<EditingStyle>);
-    RefPtrWillBeRawPtr<EditingStyle> createInlineStyleIfNeeded(Node&);
+    void wrapWithNode(ContainerNode&, RawPtr<EditingStyle>);
+    RawPtr<EditingStyle> createInlineStyleIfNeeded(Node&);
 
 private:
     bool shouldAnnotate() const;
     bool convertBlocksToInlines() const;
     void appendStartMarkup(Node&);
     void appendEndMarkup(Node&);
-    RefPtrWillBeRawPtr<EditingStyle> createInlineStyle(Element&);
+    RawPtr<EditingStyle> createInlineStyle(Element&);
     bool needsInlineStyle(const Element&);
     bool shouldApplyWrappingStyle(const Node&) const;
 
     StyledMarkupAccumulator* m_accumulator;
-    RefPtrWillBeMember<Node> m_lastClosed;
-    RefPtrWillBeMember<EditingStyle> m_wrappingStyle;
+    Member<Node> m_lastClosed;
+    Member<EditingStyle> m_wrappingStyle;
 };
 
 template<typename Strategy>
@@ -157,9 +157,9 @@ static bool areSameRanges(Node* node, const PositionTemplate<Strategy>& startPos
     return toPositionInDOMTree(startPosition) == range.startPosition() && toPositionInDOMTree(endPosition) == range.endPosition();
 }
 
-static PassRefPtrWillBeRawPtr<EditingStyle> styleFromMatchedRulesAndInlineDecl(const HTMLElement* element)
+static RawPtr<EditingStyle> styleFromMatchedRulesAndInlineDecl(const HTMLElement* element)
 {
-    RefPtrWillBeRawPtr<EditingStyle> style = EditingStyle::create(element->inlineStyle());
+    RawPtr<EditingStyle> style = EditingStyle::create(element->inlineStyle());
     // FIXME: Having to const_cast here is ugly, but it is quite a bit of work to untangle
     // the non-const-ness of styleFromMatchedRulesForElement.
     style->mergeStyleFromRules(const_cast<HTMLElement*>(element));
@@ -208,7 +208,7 @@ String StyledMarkupSerializer<Strategy>::createMarkup()
         // FIXME: What is ancestor?
         for (ContainerNode* ancestor = Strategy::parent(*lastClosed); ancestor; ancestor = Strategy::parent(*ancestor)) {
             if (ancestor == fullySelectedRoot && !markupAccumulator.convertBlocksToInlines()) {
-                RefPtrWillBeRawPtr<EditingStyle> fullySelectedRootStyle = styleFromMatchedRulesAndInlineDecl(fullySelectedRoot);
+                RawPtr<EditingStyle> fullySelectedRootStyle = styleFromMatchedRulesAndInlineDecl(fullySelectedRoot);
 
                 // Bring the background attribute over, but not as an attribute because a background attribute on a div
                 // appears to have no effect.
@@ -227,7 +227,7 @@ String StyledMarkupSerializer<Strategy>::createMarkup()
                     markupAccumulator.wrapWithStyleNode(fullySelectedRootStyle->style());
                 }
             } else {
-                RefPtrWillBeRawPtr<EditingStyle> style = traverser.createInlineStyleIfNeeded(*ancestor);
+                RawPtr<EditingStyle> style = traverser.createInlineStyleIfNeeded(*ancestor);
                 // Since this node and all the other ancestors are not in the selection we want
                 // styles that affect the exterior of the node not to be not included.
                 // If the node is not fully selected by the range, then we don't want to keep styles that affect its relationship to the nodes around it
@@ -280,7 +280,7 @@ StyledMarkupTraverser<Strategy>::StyledMarkupTraverser(StyledMarkupAccumulator*
 template<typename Strategy>
 Node* StyledMarkupTraverser<Strategy>::traverse(Node* startNode, Node* pastEnd)
 {
-    WillBeHeapVector<RawPtrWillBeMember<ContainerNode>> ancestorsToClose;
+    HeapVector<Member<ContainerNode>> ancestorsToClose;
     Node* next;
     Node* lastClosed = nullptr;
     for (Node* n = startNode; n && n != pastEnd; n = next) {
@@ -346,7 +346,7 @@ Node* StyledMarkupTraverser<Strategy>::traverse(Node* startNode, Node* pastEnd)
             // or b) ancestors that we never encountered during a pre-order traversal starting at startNode:
             ASSERT(startNode);
             ASSERT(Strategy::isDescendantOf(*startNode, *parent));
-            RefPtrWillBeRawPtr<EditingStyle> style = createInlineStyleIfNeeded(*parent);
+            RawPtr<EditingStyle> style = createInlineStyleIfNeeded(*parent);
             wrapWithNode(*parent, style);
             lastClosed = parent;
         }
@@ -366,7 +366,7 @@ bool StyledMarkupTraverser<Strategy>::needsInlineStyle(const Element& element)
 }
 
 template<typename Strategy>
-void StyledMarkupTraverser<Strategy>::wrapWithNode(ContainerNode& node, PassRefPtrWillBeRawPtr<EditingStyle> style)
+void StyledMarkupTraverser<Strategy>::wrapWithNode(ContainerNode& node, RawPtr<EditingStyle> style)
 {
     if (!m_accumulator)
         return;
@@ -388,13 +388,13 @@ void StyledMarkupTraverser<Strategy>::wrapWithNode(ContainerNode& node, PassRefP
 }
 
 template<typename Strategy>
-RefPtrWillBeRawPtr<EditingStyle> StyledMarkupTraverser<Strategy>::createInlineStyleIfNeeded(Node& node)
+RawPtr<EditingStyle> StyledMarkupTraverser<Strategy>::createInlineStyleIfNeeded(Node& node)
 {
     if (!m_accumulator)
         return nullptr;
     if (!node.isElementNode())
         return nullptr;
-    RefPtrWillBeRawPtr<EditingStyle> inlineStyle = createInlineStyle(toElement(node));
+    RawPtr<EditingStyle> inlineStyle = createInlineStyle(toElement(node));
     if (convertBlocksToInlines() && isEnclosingBlock(&node))
         inlineStyle->forceInline();
     return inlineStyle;
@@ -412,7 +412,7 @@ void StyledMarkupTraverser<Strategy>::appendStartMarkup(Node& node)
             m_accumulator->appendText(text);
             break;
         }
-        RefPtrWillBeRawPtr<EditingStyle> inlineStyle = nullptr;
+        RawPtr<EditingStyle> inlineStyle = nullptr;
         if (shouldApplyWrappingStyle(text)) {
             inlineStyle = m_wrappingStyle->copy();
             // FIXME: <rdar://problem/5371536> Style rules that match pasted content can change it's appearance
@@ -427,7 +427,7 @@ void StyledMarkupTraverser<Strategy>::appendStartMarkup(Node& node)
     case Node::ELEMENT_NODE: {
         Element& element = toElement(node);
         if ((element.isHTMLElement() && shouldAnnotate()) || shouldApplyWrappingStyle(element)) {
-            RefPtrWillBeRawPtr<EditingStyle> inlineStyle = createInlineStyle(element);
+            RawPtr<EditingStyle> inlineStyle = createInlineStyle(element);
             m_accumulator->appendElementWithInlineStyle(element, inlineStyle);
             break;
         }
@@ -456,9 +456,9 @@ bool StyledMarkupTraverser<Strategy>::shouldApplyWrappingStyle(const Node& node)
 }
 
 template<typename Strategy>
-RefPtrWillBeRawPtr<EditingStyle> StyledMarkupTraverser<Strategy>::createInlineStyle(Element& element)
+RawPtr<EditingStyle> StyledMarkupTraverser<Strategy>::createInlineStyle(Element& element)
 {
-    RefPtrWillBeRawPtr<EditingStyle> inlineStyle = nullptr;
+    RawPtr<EditingStyle> inlineStyle = nullptr;
 
     if (shouldApplyWrappingStyle(element)) {
         inlineStyle = m_wrappingStyle->copy();