Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/editing/serializers/StyledMarkupSerializer.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 74 matching lines @@
 
 template<typename Strategy>
 class StyledMarkupTraverser {
     WTF_MAKE_NONCOPYABLE(StyledMarkupTraverser);
     STACK_ALLOCATED();
 public:
     StyledMarkupTraverser();
     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>
 bool StyledMarkupTraverser<Strategy>::shouldAnnotate() const
 {
     return m_accumulator->shouldAnnotate();
 }
 
 template<typename Strategy>
 bool StyledMarkupTraverser<Strategy>::convertBlocksToInlines() const
@@ skipping 30 matching lines @@
 }
 
 template<typename Strategy>
 static bool areSameRanges(Node* node, const PositionTemplate<Strategy>& startPosition, const PositionTemplate<Strategy>& endPosition)
 {
     ASSERT(node);
     const EphemeralRange range = VisibleSelection::selectionFromContentsOfNode(node).toNormalizedEphemeralRange();
     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));
     return style.release();
 }
 
 template<typename Strategy>
 String StyledMarkupSerializer<Strategy>::createMarkup()
 {
     StyledMarkupAccumulator markupAccumulator(m_shouldResolveURLs, toTextOffset(m_start.parentAnchoredEquivalent()), toTextOffset(m_end.parentAnchoredEquivalent()), m_start.document(), m_shouldAnnotate, m_convertBlocksToInlines);
@@ skipping 28 matching lines @@
         HTMLBodyElement* body = toHTMLBodyElement(enclosingElementWithTag(firstPositionInNode(commonAncestor), bodyTag));
         HTMLBodyElement* fullySelectedRoot = nullptr;
         // FIXME: Do this for all fully selected blocks, not just the body.
         if (body && areSameRanges(body, m_start, m_end))
             fullySelectedRoot = body;
 
         // Also include all of the ancestors of lastClosed up to this special ancestor.
         // 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.
                 if ((!fullySelectedRootStyle || !fullySelectedRootStyle->style() || !fullySelectedRootStyle->style()->getPropertyCSSValue(CSSPropertyBackgroundImage))
                     && fullySelectedRoot->hasAttribute(backgroundAttr))
                     fullySelectedRootStyle->style()->setProperty(CSSPropertyBackgroundImage, "url('" + fullySelectedRoot->getAttribute(backgroundAttr) + "')");
 
                 if (fullySelectedRootStyle->style()) {
                     // Reset the CSS properties to avoid an assertion error in addStyleMarkup().
                     // This assertion is caused at least when we select all text of a <body> element whose
                     // 'text-decoration' property is "inherit", and copy it.
                     if (!propertyMissingOrEqualToNone(fullySelectedRootStyle->style(), CSSPropertyTextDecoration))
                         fullySelectedRootStyle->style()->setProperty(CSSPropertyTextDecoration, CSSValueNone);
                     if (!propertyMissingOrEqualToNone(fullySelectedRootStyle->style(), CSSPropertyWebkitTextDecorationsInEffect))
                         fullySelectedRootStyle->style()->setProperty(CSSPropertyWebkitTextDecorationsInEffect, CSSValueNone);
                     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
                 // only the ones that affect it and the nodes within it.
                 if (style && style->style())
                     style->style()->removeProperty(CSSPropertyFloat);
                 traverser.wrapWithNode(*ancestor, style);
             }
 
             if (ancestor == m_highestNodeToBeSerialized)
@@ skipping 32 matching lines @@
     if (shouldAnnotate()) {
         m_wrappingStyle = EditingStyle::wrappingStyleForAnnotatedSerialization(parent);
         return;
     }
     m_wrappingStyle = EditingStyle::wrappingStyleForSerialization(parent);
 }
 
 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) {
         // If |n| is a selection boundary such as <input>, traverse the child
         // nodes in the DOM tree instead of the flat tree.
         if (handleSelectionBoundary<Strategy>(*n)) {
             lastClosed = StyledMarkupTraverser<EditingStrategy>(m_accumulator, m_lastClosed.get()).traverse(n, EditingStrategy::nextSkippingChildren(*n));
             next = EditingInFlatTreeStrategy::nextSkippingChildren(*n);
         } else {
             next = Strategy::next(*n);
@@ skipping 45 matching lines @@
 
         ASSERT(n);
         Node* lastAncestorClosedOrSelf = (lastClosed && Strategy::isDescendantOf(*n, *lastClosed)) ? lastClosed : n;
         for (ContainerNode* parent = Strategy::parent(*lastAncestorClosedOrSelf); parent && parent != nextParent; parent = Strategy::parent(*parent)) {
             // All ancestors that aren't in the ancestorsToClose list should either be a) unrendered:
             if (!parent->layoutObject())
                 continue;
             // 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;
         }
     }
 
     return lastClosed;
 }
 
 template<typename Strategy>
 bool StyledMarkupTraverser<Strategy>::needsInlineStyle(const Element& element)
 {
     if (!element.isHTMLElement())
         return false;
     if (shouldAnnotate())
         return true;
     return convertBlocksToInlines() && isEnclosingBlock(&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;
     StringBuilder markup;
     if (node.isDocumentNode()) {
         MarkupFormatter::appendXMLDeclaration(markup, toDocument(node));
         m_accumulator->pushMarkup(markup.toString());
         return;
     }
     if (!node.isElementNode())
         return;
     Element& element = toElement(node);
     if (shouldApplyWrappingStyle(element) || needsInlineStyle(element))
         m_accumulator->appendElementWithInlineStyle(markup, element, style);
     else
         m_accumulator->appendElement(markup, element);
     m_accumulator->pushMarkup(markup.toString());
     m_accumulator->appendEndTag(toElement(node));
 }
 
 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;
 }
 
 template<typename Strategy>
 void StyledMarkupTraverser<Strategy>::appendStartMarkup(Node& node)
 {
     if (!m_accumulator)
         return;
     switch (node.nodeType()) {
     case Node::TEXT_NODE: {
         Text& text = toText(node);
         if (text.parentElement() && isHTMLTextAreaElement(text.parentElement())) {
             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
             // Make sure spans are inline style in paste side e.g. span { display: block }.
             inlineStyle->forceInline();
             // FIXME: Should this be included in forceInline?
             inlineStyle->style()->setProperty(CSSPropertyFloat, CSSValueNone);
         }
         m_accumulator->appendTextWithInlineStyle(text, inlineStyle);
         break;
     }
     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;
         }
         m_accumulator->appendElement(element);
         break;
     }
     default:
         m_accumulator->appendStartMarkup(node);
         break;
     }
 }
 
 template<typename Strategy>
 void StyledMarkupTraverser<Strategy>::appendEndMarkup(Node& node)
 {
     if (!m_accumulator || !node.isElementNode())
         return;
     m_accumulator->appendEndTag(toElement(node));
 }
 
 template<typename Strategy>
 bool StyledMarkupTraverser<Strategy>::shouldApplyWrappingStyle(const Node& node) const
 {
     return m_lastClosed && Strategy::parent(*m_lastClosed) == Strategy::parent(node)
         && m_wrappingStyle && m_wrappingStyle->style();
 }
 
 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();
         inlineStyle->removePropertiesInElementDefaultStyle(&element);
         inlineStyle->removeStyleConflictingWithStyleOfElement(&element);
     } else {
         inlineStyle = EditingStyle::create();
     }
 
     if (element.isStyledElement() && element.inlineStyle())
         inlineStyle->overrideWithStyle(element.inlineStyle());
 
     if (element.isHTMLElement() && shouldAnnotate())
         inlineStyle->mergeStyleFromRulesForSerialization(&toHTMLElement(element));
 
     return inlineStyle;
 }
 
 template class StyledMarkupSerializer<EditingStrategy>;
 template class StyledMarkupSerializer<EditingInFlatTreeStrategy>;
 
 } // namespace blink