Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/editing/commands/ApplyStyleCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2008, 2009 Apple Inc. 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 122 matching lines @@
     , m_propertyLevel(PropertyDefault)
     , m_start(start)
     , m_end(end)
     , m_useEndingSelection(false)
     , m_styledInlineElement(nullptr)
     , m_removeOnly(false)
     , m_isInlineElementToRemoveFunction(0)
 {
 }
 
-ApplyStyleCommand::ApplyStyleCommand(PassRefPtrWillBeRawPtr<Element> element, bool removeOnly)
+ApplyStyleCommand::ApplyStyleCommand(RawPtr<Element> element, bool removeOnly)
     : CompositeEditCommand(element->document())
     , m_style(EditingStyle::create())
     , m_editingAction(EditActionChangeAttributes)
     , m_propertyLevel(PropertyDefault)
     , m_start(mostForwardCaretPosition(endingSelection().start()))
     , m_end(mostBackwardCaretPosition(endingSelection().end()))
     , m_useEndingSelection(true)
     , m_styledInlineElement(element)
     , m_removeOnly(removeOnly)
     , m_isInlineElementToRemoveFunction(0)
@@ skipping 40 matching lines @@
         return endingSelection().end();
 
     return m_end;
 }
 
 void ApplyStyleCommand::doApply(EditingState* editingState)
 {
     switch (m_propertyLevel) {
     case PropertyDefault: {
         // Apply the block-centric properties of the style.
-        RefPtrWillBeRawPtr<EditingStyle> blockStyle = m_style->extractAndRemoveBlockProperties();
+        RawPtr<EditingStyle> blockStyle = m_style->extractAndRemoveBlockProperties();
         if (!blockStyle->isEmpty()) {
             applyBlockStyle(blockStyle.get(), editingState);
             if (editingState->isAborted())
                 return;
         }
         // Apply any remaining styles to the inline elements.
         if (!m_style->isEmpty() || m_styledInlineElement || m_isInlineElementToRemoveFunction) {
             applyRelativeFontStyleChange(m_style.get(), editingState);
             if (editingState->isAborted())
                 return;
@@ skipping 34 matching lines @@
     VisiblePosition visibleStart = createVisiblePosition(start);
     VisiblePosition visibleEnd = createVisiblePosition(end);
 
     if (visibleStart.isNull() || visibleStart.isOrphan() || visibleEnd.isNull() || visibleEnd.isOrphan())
         return;
 
     // Save and restore the selection endpoints using their indices in the document, since
     // addBlockStyleIfNeeded may moveParagraphs, which can remove these endpoints.
     // Calculate start and end indices from the start of the tree that they're in.
     Node& scope = NodeTraversal::highestAncestorOrSelf(*visibleStart.deepEquivalent().anchorNode());
-    RefPtrWillBeRawPtr<Range> startRange = Range::create(document(), firstPositionInNode(&scope), visibleStart.deepEquivalent().parentAnchoredEquivalent());
-    RefPtrWillBeRawPtr<Range> endRange = Range::create(document(), firstPositionInNode(&scope), visibleEnd.deepEquivalent().parentAnchoredEquivalent());
+    RawPtr<Range> startRange = Range::create(document(), firstPositionInNode(&scope), visibleStart.deepEquivalent().parentAnchoredEquivalent());
+    RawPtr<Range> endRange = Range::create(document(), firstPositionInNode(&scope), visibleEnd.deepEquivalent().parentAnchoredEquivalent());
     int startIndex = TextIterator::rangeLength(startRange->startPosition(), startRange->endPosition(), true);
     int endIndex = TextIterator::rangeLength(endRange->startPosition(), endRange->endPosition(), true);
 
     VisiblePosition paragraphStart(startOfParagraph(visibleStart));
     VisiblePosition nextParagraphStart(nextPositionOf(endOfParagraph(paragraphStart)));
     VisiblePosition beyondEnd(nextPositionOf(endOfParagraph(visibleEnd)));
     while (paragraphStart.isNotNull() && paragraphStart.deepEquivalent() != beyondEnd.deepEquivalent()) {
         StyleChange styleChange(style, paragraphStart.deepEquivalent());
         if (styleChange.cssStyle().length() || m_removeOnly) {
-            RefPtrWillBeRawPtr<Element> block = enclosingBlock(paragraphStart.deepEquivalent().anchorNode());
+            RawPtr<Element> block = enclosingBlock(paragraphStart.deepEquivalent().anchorNode());
             const Position& paragraphStartToMove = paragraphStart.deepEquivalent();
             if (!m_removeOnly && isEditablePosition(paragraphStartToMove)) {
-                RefPtrWillBeRawPtr<HTMLElement> newBlock = moveParagraphContentsToNewBlockIfNecessary(paragraphStartToMove, editingState);
+                RawPtr<HTMLElement> newBlock = moveParagraphContentsToNewBlockIfNecessary(paragraphStartToMove, editingState);
                 if (editingState->isAborted())
                     return;
                 if (newBlock)
                     block = newBlock;
             }
             if (block && block->isHTMLElement()) {
                 removeCSSStyle(style, toHTMLElement(block), editingState);
                 if (editingState->isAborted())
                     return;
                 if (!m_removeOnly)
@@ skipping 10 matching lines @@
 
     EphemeralRange startEphemeralRange = PlainTextRange(startIndex).createRangeForSelection(toContainerNode(scope));
     if (startEphemeralRange.isNull())
         return;
     EphemeralRange endEphemeralRange = PlainTextRange(endIndex).createRangeForSelection(toContainerNode(scope));
     if (endEphemeralRange.isNull())
         return;
     updateStartEnd(startEphemeralRange.startPosition(), endEphemeralRange.startPosition());
 }
 
-static PassRefPtrWillBeRawPtr<MutableStylePropertySet> copyStyleOrCreateEmpty(const StylePropertySet* style)
+static RawPtr<MutableStylePropertySet> copyStyleOrCreateEmpty(const StylePropertySet* style)
 {
     if (!style)
         return MutableStylePropertySet::create(HTMLQuirksMode);
     return style->mutableCopy();
 }
 
 void ApplyStyleCommand::applyRelativeFontStyleChange(EditingStyle* style, EditingState* editingState)
 {
     static const float MinimumFontSize = 0.1f;
 
@@ skipping 62 matching lines @@
 
     if (startNode->isTextNode() && start.computeOffsetInContainerNode() >= caretMaxOffset(startNode)) {
         // Move out of text node if range does not include its characters.
         startNode = NodeTraversal::next(*startNode);
         if (!startNode)
             return;
     }
 
     // Store away font size before making any changes to the document.
     // This ensures that changes to one node won't effect another.
-    WillBeHeapHashMap<RawPtrWillBeMember<Node>, float> startingFontSizes;
+    HeapHashMap<Member<Node>, float> startingFontSizes;
     for (Node* node = startNode; node != beyondEnd; node = NodeTraversal::next(*node)) {
         ASSERT(node);
         startingFontSizes.set(node, computedFontSize(node));
     }
 
     // These spans were added by us. If empty after font size changes, they can be removed.
-    WillBeHeapVector<RefPtrWillBeMember<HTMLElement>> unstyledSpans;
+    HeapVector<Member<HTMLElement>> unstyledSpans;
 
     Node* lastStyledNode = nullptr;
     for (Node* node = startNode; node != beyondEnd; node = NodeTraversal::next(*node)) {
         ASSERT(node);
-        RefPtrWillBeRawPtr<HTMLElement> element = nullptr;
+        RawPtr<HTMLElement> element = nullptr;
         if (node->isHTMLElement()) {
             // Only work on fully selected nodes.
             if (!elementFullySelected(toHTMLElement(*node), start, end))
                 continue;
             element = toHTMLElement(node);
         } else if (node->isTextNode() && node->layoutObject() && node->parentNode() != lastStyledNode) {
             // Last styled node was not parent node of this text node, but we wish to style this
             // text node. To make this possible, add a style span to surround this text node.
-            RefPtrWillBeRawPtr<HTMLSpanElement> span = HTMLSpanElement::create(document());
+            RawPtr<HTMLSpanElement> span = HTMLSpanElement::create(document());
             surroundNodeRangeWithElement(node, node, span.get(), editingState);
             if (editingState->isAborted())
                 return;
             element = span.release();
         }  else {
             // Only handle HTML elements and text nodes.
             continue;
         }
         lastStyledNode = node;
 
-        RefPtrWillBeRawPtr<MutableStylePropertySet> inlineStyle = copyStyleOrCreateEmpty(element->inlineStyle());
+        RawPtr<MutableStylePropertySet> inlineStyle = copyStyleOrCreateEmpty(element->inlineStyle());
         float currentFontSize = computedFontSize(node);
         float desiredFontSize = max(MinimumFontSize, startingFontSizes.get(node) + style->fontSizeDelta());
-        RefPtrWillBeRawPtr<CSSValue> value = inlineStyle->getPropertyCSSValue(CSSPropertyFontSize);
+        RawPtr<CSSValue> value = inlineStyle->getPropertyCSSValue(CSSPropertyFontSize);
         if (value) {
             element->removeInlineStyleProperty(CSSPropertyFontSize);
             currentFontSize = computedFontSize(node);
         }
         if (currentFontSize != desiredFontSize) {
             inlineStyle->setProperty(CSSPropertyFontSize, cssValuePool().createValue(desiredFontSize, CSSPrimitiveValue::UnitType::Pixels), false);
             setNodeAttribute(element.get(), styleAttr, AtomicString(inlineStyle->asText()));
         }
         if (inlineStyle->isEmpty()) {
             removeElementAttribute(element.get(), styleAttr);
@@ skipping 69 matching lines @@
         && EditingStyle::create(highestAncestorWithUnicodeBidi, EditingStyle::AllProperties)->textDirection(highestAncestorDirection)
         && highestAncestorDirection == allowedDirection) {
         if (!nextHighestAncestorWithUnicodeBidi)
             return toHTMLElement(highestAncestorWithUnicodeBidi);
 
         unsplitAncestor = toHTMLElement(highestAncestorWithUnicodeBidi);
         highestAncestorWithUnicodeBidi = nextHighestAncestorWithUnicodeBidi;
     }
 
     // Split every ancestor through highest ancestor with embedding.
-    RefPtrWillBeRawPtr<Node> currentNode = node;
+    RawPtr<Node> currentNode = node;
     while (currentNode) {
-        RefPtrWillBeRawPtr<Element> parent = toElement(currentNode->parentNode());
+        RawPtr<Element> parent = toElement(currentNode->parentNode());
         if (before ? currentNode->previousSibling() : currentNode->nextSibling())
             splitElement(parent, before ? currentNode.get() : currentNode->nextSibling());
         if (parent == highestAncestorWithUnicodeBidi)
             break;
         currentNode = parent;
     }
     return unsplitAncestor;
 }
 
 void ApplyStyleCommand::removeEmbeddingUpToEnclosingBlock(Node* node, HTMLElement* unsplitAncestor, EditingState* editingState)
@@ skipping 13 matching lines @@
 
         // FIXME: This code should really consider the mapped attribute 'dir', the inline style declaration,
         // and all matching style rules in order to determine how to best set the unicode-bidi property to 'normal'.
         // For now, it assumes that if the 'dir' attribute is present, then removing it will suffice, and
         // otherwise it sets the property in the inline style declaration.
         if (element->hasAttribute(dirAttr)) {
             // FIXME: If this is a BDO element, we should probably just remove it if it has no
             // other attributes, like we (should) do with B and I elements.
             removeElementAttribute(element, dirAttr);
         } else {
-            RefPtrWillBeRawPtr<MutableStylePropertySet> inlineStyle = copyStyleOrCreateEmpty(element->inlineStyle());
+            RawPtr<MutableStylePropertySet> inlineStyle = copyStyleOrCreateEmpty(element->inlineStyle());
             inlineStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueNormal);
             inlineStyle->removeProperty(CSSPropertyDirection);
             setNodeAttribute(element, styleAttr, AtomicString(inlineStyle->asText()));
             if (isSpanWithoutAttributesOrUnstyledStyleSpan(element)) {
                 removeNodePreservingChildren(element, editingState);
                 if (editingState->isAborted())
                     return;
             }
         }
     }
 }
 
 static HTMLElement* highestEmbeddingAncestor(Node* startNode, Node* enclosingNode)
 {
     for (Node* n = startNode; n && n != enclosingNode; n = n->parentNode()) {
         if (n->isHTMLElement()
             && EditingStyle::isEmbedOrIsolate(getIdentifierValue(CSSComputedStyleDeclaration::create(n).get(), CSSPropertyUnicodeBidi))) {
             return toHTMLElement(n);
         }
     }
 
     return 0;
 }
 
 void ApplyStyleCommand::applyInlineStyle(EditingStyle* style, EditingState* editingState)
 {
-    RefPtrWillBeRawPtr<ContainerNode> startDummySpanAncestor = nullptr;
-    RefPtrWillBeRawPtr<ContainerNode> endDummySpanAncestor = nullptr;
+    RawPtr<ContainerNode> startDummySpanAncestor = nullptr;
+    RawPtr<ContainerNode> endDummySpanAncestor = nullptr;
 
     // update document layout once before removing styles
     // so that we avoid the expense of updating before each and every call
     // to check a computed style
     document().updateLayoutIgnorePendingStylesheets();
 
     // adjust to the positions we want to use for applying style
     Position start = startPosition();
     Position end = endPosition();
 
@@ skipping 35 matching lines @@
     }
 
     // Remove style from the selection.
     // Use the upstream position of the start for removing style.
     // This will ensure we remove all traces of the relevant styles from the selection
     // and prevent us from adding redundant ones, as described in:
     // <rdar://problem/3724344> Bolding and unbolding creates extraneous tags
     Position removeStart = mostBackwardCaretPosition(start);
     WritingDirection textDirection = NaturalWritingDirection;
     bool hasTextDirection = style->textDirection(textDirection);
-    RefPtrWillBeRawPtr<EditingStyle> styleWithoutEmbedding = nullptr;
-    RefPtrWillBeRawPtr<EditingStyle> embeddingStyle = nullptr;
+    RawPtr<EditingStyle> styleWithoutEmbedding = nullptr;
+    RawPtr<EditingStyle> embeddingStyle = nullptr;
     if (hasTextDirection) {
         // Leave alone an ancestor that provides the desired single level embedding, if there is one.
         HTMLElement* startUnsplitAncestor = splitAncestorsWithUnicodeBidi(start.anchorNode(), true, textDirection);
         HTMLElement* endUnsplitAncestor = splitAncestorsWithUnicodeBidi(end.anchorNode(), false, textDirection);
         removeEmbeddingUpToEnclosingBlock(start.anchorNode(), startUnsplitAncestor, editingState);
         if (editingState->isAborted())
             return;
         removeEmbeddingUpToEnclosingBlock(end.anchorNode(), endUnsplitAncestor, editingState);
         if (editingState->isAborted())
             return;
@@ skipping 43 matching lines @@
             return;
         start = startPosition();
         end = endPosition();
     }
 
     // update document layout once before running the rest of the function
     // so that we avoid the expense of updating before each and every call
     // to check a computed style
     document().updateLayoutIgnorePendingStylesheets();
 
-    RefPtrWillBeRawPtr<EditingStyle> styleToApply = style;
+    RawPtr<EditingStyle> styleToApply = style;
     if (hasTextDirection) {
         // Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.
         HTMLElement* embeddingStartElement = highestEmbeddingAncestor(start.anchorNode(), enclosingBlock(start.anchorNode()));
         HTMLElement* embeddingEndElement = highestEmbeddingAncestor(end.anchorNode(), enclosingBlock(end.anchorNode()));
 
         if (embeddingStartElement || embeddingEndElement) {
             Position embeddingApplyStart = embeddingStartElement ? positionInParentAfterNode(*embeddingStartElement) : start;
             Position embeddingApplyEnd = embeddingEndElement ? positionInParentBeforeNode(*embeddingEndElement) : end;
             ASSERT(embeddingApplyStart.isNotNull() && embeddingApplyEnd.isNotNull());
 
@@ skipping 37 matching lines @@
         pastEndNode = NodeTraversal::nextSkippingChildren(*end.anchorNode());
 
     // FIXME: Callers should perform this operation on a Range that includes the br
     // if they want style applied to the empty line.
     if (start == end && isHTMLBRElement(*start.anchorNode()))
         pastEndNode = NodeTraversal::next(*start.anchorNode());
 
     // Start from the highest fully selected ancestor so that we can modify the fully selected node.
     // e.g. When applying font-size: large on <font color="blue">hello</font>, we need to include the font element in our run
     // to generate <font color="blue" size="4">hello</font> instead of <font color="blue"><font size="4">hello</font></font>
-    RefPtrWillBeRawPtr<Range> range = Range::create(startNode->document(), start, end);
+    RawPtr<Range> range = Range::create(startNode->document(), start, end);
     Element* editableRoot = startNode->rootEditableElement();
     if (startNode != editableRoot) {
         while (editableRoot && startNode->parentNode() != editableRoot && isNodeVisiblyContainedWithin(*startNode->parentNode(), *range))
             startNode = startNode->parentNode();
     }
 
     applyInlineStyleToNodeRange(style, startNode, pastEndNode, editingState);
 }
 
 static bool containsNonEditableRegion(Node& node)
@@ skipping 28 matching lines @@
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(start);
         visitor->trace(end);
         visitor->trace(pastEndNode);
         visitor->trace(positionForStyleComputation);
         visitor->trace(dummyElement);
     }
 
-    RefPtrWillBeMember<Node> start;
-    RefPtrWillBeMember<Node> end;
-    RefPtrWillBeMember<Node> pastEndNode;
+    Member<Node> start;
+    Member<Node> end;
+    Member<Node> pastEndNode;
     Position positionForStyleComputation;
-    RefPtrWillBeMember<HTMLSpanElement> dummyElement;
+    Member<HTMLSpanElement> dummyElement;
     StyleChange change;
 };
 
 } // namespace blink
 
 WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::InlineRunToApplyStyle);
 
 namespace blink {
 
-void ApplyStyleCommand::applyInlineStyleToNodeRange(EditingStyle* style, PassRefPtrWillBeRawPtr<Node> startNode, PassRefPtrWillBeRawPtr<Node> pastEndNode, EditingState* editingState)
+void ApplyStyleCommand::applyInlineStyleToNodeRange(EditingStyle* style, RawPtr<Node> startNode, RawPtr<Node> pastEndNode, EditingState* editingState)
 {
     if (m_removeOnly)
         return;
 
     document().updateLayoutIgnorePendingStylesheets();
 
-    WillBeHeapVector<InlineRunToApplyStyle> runs;
-    RefPtrWillBeRawPtr<Node> node = startNode;
-    for (RefPtrWillBeRawPtr<Node> next; node && node != pastEndNode; node = next) {
+    HeapVector<InlineRunToApplyStyle> runs;
+    RawPtr<Node> node = startNode;
+    for (RawPtr<Node> next; node && node != pastEndNode; node = next) {
         next = NodeTraversal::next(*node);
 
         if (!node->layoutObject() || !node->hasEditableStyle())
             continue;
 
         if (!node->layoutObjectIsRichlyEditable() && node->isHTMLElement()) {
             HTMLElement* element = toHTMLElement(node);
             // This is a plaintext-only region. Only proceed if it's fully selected.
             // pastEndNode is the node after the last fully selected node, so if it's inside node then
             // node isn't fully selected.
             if (pastEndNode && pastEndNode->isDescendantOf(element))
                 break;
             // Add to this element's inline style and skip over its contents.
             next = NodeTraversal::nextSkippingChildren(*node);
             if (!style->style())
                 continue;
-            RefPtrWillBeRawPtr<MutableStylePropertySet> inlineStyle = copyStyleOrCreateEmpty(element->inlineStyle());
+            RawPtr<MutableStylePropertySet> inlineStyle = copyStyleOrCreateEmpty(element->inlineStyle());
             inlineStyle->mergeAndOverrideOnConflict(style->style());
             setNodeAttribute(element, styleAttr, AtomicString(inlineStyle->asText()));
             continue;
         }
 
         if (isEnclosingBlock(node.get()))
             continue;
 
         if (node->hasChildren()) {
             if (node->contains(pastEndNode.get()) || containsNonEditableRegion(*node) || !node->parentNode()->hasEditableStyle())
@@ skipping 70 matching lines @@
             continue;
         // We don't consider m_isInlineElementToRemoveFunction here because we never apply style when m_isInlineElementToRemoveFunction is specified
         if (!style->styleIsPresentInComputedStyleOfNode(node))
             return true;
         if (m_styledInlineElement && !enclosingElementWithTag(positionBeforeNode(node), m_styledInlineElement->tagQName()))
             return true;
     }
     return false;
 }
 
-void ApplyStyleCommand::removeConflictingInlineStyleFromRun(EditingStyle* style, RefPtrWillBeMember<Node>& runStart, RefPtrWillBeMember<Node>& runEnd, PassRefPtrWillBeRawPtr<Node> pastEndNode, EditingState* editingState)
+void ApplyStyleCommand::removeConflictingInlineStyleFromRun(EditingStyle* style, Member<Node>& runStart, Member<Node>& runEnd, RawPtr<Node> pastEndNode, EditingState* editingState)
 {
     ASSERT(runStart && runEnd);
-    RefPtrWillBeRawPtr<Node> next = runStart;
-    for (RefPtrWillBeRawPtr<Node> node = next; node && node->inDocument() && node != pastEndNode; node = next) {
+    RawPtr<Node> next = runStart;
+    for (RawPtr<Node> node = next; node && node->inDocument() && node != pastEndNode; node = next) {
         if (editingIgnoresContent(node.get())) {
             ASSERT(!node->contains(pastEndNode.get()));
             next = NodeTraversal::nextSkippingChildren(*node);
         } else {
             next = NodeTraversal::next(*node);
         }
         if (!node->isHTMLElement())
             continue;
 
         HTMLElement& element = toHTMLElement(*node);
-        RefPtrWillBeRawPtr<Node> previousSibling = element.previousSibling();
-        RefPtrWillBeRawPtr<Node> nextSibling = element.nextSibling();
-        RefPtrWillBeRawPtr<ContainerNode> parent = element.parentNode();
+        RawPtr<Node> previousSibling = element.previousSibling();
+        RawPtr<Node> nextSibling = element.nextSibling();
+        RawPtr<ContainerNode> parent = element.parentNode();
         removeInlineStyleFromElement(style, &element, editingState, RemoveAlways);
         if (editingState->isAborted())
             return;
         if (!element.inDocument()) {
             // FIXME: We might need to update the start and the end of current selection here but need a test.
             if (runStart == element)
                 runStart = previousSibling ? previousSibling->nextSibling() : parent->firstChild();
             if (runEnd == element)
                 runEnd = nextSibling ? nextSibling->previousSibling() : parent->lastChild();
         }
     }
 }
 
-bool ApplyStyleCommand::removeInlineStyleFromElement(EditingStyle* style, PassRefPtrWillBeRawPtr<HTMLElement> element, EditingState* editingState, InlineStyleRemovalMode mode, EditingStyle* extractedStyle)
+bool ApplyStyleCommand::removeInlineStyleFromElement(EditingStyle* style, RawPtr<HTMLElement> element, EditingState* editingState, InlineStyleRemovalMode mode, EditingStyle* extractedStyle)
 {
     ASSERT(element);
 
     if (!element->parentNode() || !element->parentNode()->isContentEditable(Node::UserSelectAllIsAlwaysNonEditable))
         return false;
 
     if (isStyledInlineElementToRemove(element.get())) {
         if (mode == RemoveNone)
             return true;
         if (extractedStyle)
@@ skipping 107 matching lines @@
 
 void ApplyStyleCommand::applyInlineStyleToPushDown(Node* node, EditingStyle* style, EditingState* editingState)
 {
     ASSERT(node);
 
     node->document().updateLayoutTree();
 
     if (!style || style->isEmpty() || !node->layoutObject() || isHTMLIFrameElement(*node))
         return;
 
-    RefPtrWillBeRawPtr<EditingStyle> newInlineStyle = style;
+    RawPtr<EditingStyle> newInlineStyle = style;
     if (node->isHTMLElement() && toHTMLElement(node)->inlineStyle()) {
         newInlineStyle = style->copy();
         newInlineStyle->mergeInlineStyleOfElement(toHTMLElement(node), EditingStyle::OverrideValues);
     }
 
     // Since addInlineStyleIfNeeded can't add styles to block-flow layout objects, add style attribute instead.
     // FIXME: applyInlineStyleToRange should be used here instead.
     if ((node->layoutObject()->isLayoutBlockFlow() || node->hasChildren()) && node->isHTMLElement()) {
         setNodeAttribute(toHTMLElement(node), styleAttr, AtomicString(newInlineStyle->style()->asText()));
         return;
     }
 
     if (node->layoutObject()->isText() && toLayoutText(node->layoutObject())->isAllCollapsibleWhitespace())
         return;
 
     // We can't wrap node with the styled element here because new styled element will never be removed if we did.
     // If we modified the child pointer in pushDownInlineStyleAroundNode to point to new style element
     // then we fall into an infinite loop where we keep removing and adding styled element wrapping node.
     addInlineStyleIfNeeded(newInlineStyle.get(), node, node, editingState);
 }
 
 void ApplyStyleCommand::pushDownInlineStyleAroundNode(EditingStyle* style, Node* targetNode, EditingState* editingState)
 {
     HTMLElement* highestAncestor = highestAncestorWithConflictingInlineStyle(style, targetNode);
     if (!highestAncestor)
         return;
 
     // The outer loop is traversing the tree vertically from highestAncestor to targetNode
-    RefPtrWillBeRawPtr<Node> current = highestAncestor;
+    RawPtr<Node> current = highestAncestor;
     // Along the way, styled elements that contain targetNode are removed and accumulated into elementsToPushDown.
     // Each child of the removed element, exclusing ancestors of targetNode, is then wrapped by clones of elements in elementsToPushDown.
-    WillBeHeapVector<RefPtrWillBeMember<Element>> elementsToPushDown;
+    HeapVector<Member<Element>> elementsToPushDown;
     while (current && current != targetNode && current->contains(targetNode)) {
         NodeVector currentChildren;
         getChildNodes(toContainerNode(*current), currentChildren);
-        RefPtrWillBeRawPtr<Element> styledElement = nullptr;
+        RawPtr<Element> styledElement = nullptr;
         if (current->isStyledElement() && isStyledInlineElementToRemove(toElement(current))) {
             styledElement = toElement(current);
             elementsToPushDown.append(styledElement);
         }
 
-        RefPtrWillBeRawPtr<EditingStyle> styleToPushDown = EditingStyle::create();
+        RawPtr<EditingStyle> styleToPushDown = EditingStyle::create();
         if (current->isHTMLElement()) {
             removeInlineStyleFromElement(style, toHTMLElement(current), editingState, RemoveIfNeeded, styleToPushDown.get());
             if (editingState->isAborted())
                 return;
         }
 
         // The inner loop will go through children on each level
         // FIXME: we should aggregate inline child elements together so that we don't wrap each child separately.
         for (const auto& currentChild : currentChildren) {
             Node* child = currentChild.get();
             if (!child->parentNode())
                 continue;
             if (!child->contains(targetNode) && elementsToPushDown.size()) {
                 for (const auto& element : elementsToPushDown) {
-                    RefPtrWillBeRawPtr<Element> wrapper = element->cloneElementWithoutChildren();
+                    RawPtr<Element> wrapper = element->cloneElementWithoutChildren();
                     wrapper->removeAttribute(styleAttr);
                     // Delete id attribute from the second element because the same id cannot be used for more than one element
                     element->removeAttribute(HTMLNames::idAttr);
                     if (isHTMLAnchorElement(element))
                         element->removeAttribute(HTMLNames::nameAttr);
                     surroundNodeRangeWithElement(child, child, wrapper, editingState);
                     if (editingState->isAborted())
                         return;
                 }
             }
@@ skipping 52 matching lines @@
     // If pushDownInlineStyleAroundNode has pruned start.anchorNode() or end.anchorNode(),
     // use pushDownStart or pushDownEnd instead, which pushDownInlineStyleAroundNode won't prune.
     Position s = start.isNull() || start.isOrphan() ? pushDownStart : start;
     Position e = end.isNull() || end.isOrphan() ? pushDownEnd : end;
 
     // Current ending selection resetting algorithm assumes |start| and |end|
     // are in a same DOM tree even if they are not in document.
     if (!Position::commonAncestorTreeScope(start, end))
         return;
 
-    RefPtrWillBeRawPtr<Node> node = start.anchorNode();
+    RawPtr<Node> node = start.anchorNode();
     while (node) {
-        RefPtrWillBeRawPtr<Node> next = nullptr;
+        RawPtr<Node> next = nullptr;
         if (editingIgnoresContent(node.get())) {
             ASSERT(node == end.anchorNode() || !node->contains(end.anchorNode()));
             next = NodeTraversal::nextSkippingChildren(*node);
         } else {
             next = NodeTraversal::next(*node);
         }
         if (node->isHTMLElement() && elementFullySelected(toHTMLElement(*node), start, end)) {
-            RefPtrWillBeRawPtr<HTMLElement> elem = toHTMLElement(node);
-            RefPtrWillBeRawPtr<Node> prev = NodeTraversal::previousPostOrder(*elem);
-            RefPtrWillBeRawPtr<Node> next = NodeTraversal::next(*elem);
-            RefPtrWillBeRawPtr<EditingStyle> styleToPushDown = nullptr;
-            RefPtrWillBeRawPtr<Node> childNode = nullptr;
+            RawPtr<HTMLElement> elem = toHTMLElement(node);
+            RawPtr<Node> prev = NodeTraversal::previousPostOrder(*elem);
+            RawPtr<Node> next = NodeTraversal::next(*elem);
+            RawPtr<EditingStyle> styleToPushDown = nullptr;
+            RawPtr<Node> childNode = nullptr;
             if (isStyledInlineElementToRemove(elem.get())) {
                 styleToPushDown = EditingStyle::create();
                 childNode = elem->firstChild();
             }
 
             removeInlineStyleFromElement(style, elem.get(), editingState, RemoveIfNeeded, styleToPushDown.get());
             if (editingState->isAborted())
                 return;
             if (!elem->inDocument()) {
                 if (s.anchorNode() == elem) {
@@ skipping 39 matching lines @@
 void ApplyStyleCommand::splitTextAtStart(const Position& start, const Position& end)
 {
     ASSERT(start.computeContainerNode()->isTextNode());
 
     Position newEnd;
     if (end.isOffsetInAnchor() && start.computeContainerNode() == end.computeContainerNode())
         newEnd = Position(end.computeContainerNode(), end.offsetInContainerNode() - start.offsetInContainerNode());
     else
         newEnd = end;
 
-    RefPtrWillBeRawPtr<Text> text = toText(start.computeContainerNode());
+    RawPtr<Text> text = toText(start.computeContainerNode());
     splitTextNode(text, start.offsetInContainerNode());
     updateStartEnd(firstPositionInNode(text.get()), newEnd);
 }
 
 void ApplyStyleCommand::splitTextAtEnd(const Position& start, const Position& end)
 {
     ASSERT(end.computeContainerNode()->isTextNode());
 
     bool shouldUpdateStart = start.isOffsetInAnchor() && start.computeContainerNode() == end.computeContainerNode();
     Text* text = toText(end.anchorNode());
@@ skipping 129 matching lines @@
         bool shouldUpdateStart = start.computeContainerNode() == endNode;
         int endOffset = nextChild ? nextChild->nodeIndex() : nextElement->childNodes()->length();
         updateStartEnd(shouldUpdateStart ? Position(nextElement, start.offsetInContainerNode()) : start,
             Position(nextElement, endOffset));
         return true;
     }
 
     return false;
 }
 
-void ApplyStyleCommand::surroundNodeRangeWithElement(PassRefPtrWillBeRawPtr<Node> passedStartNode, PassRefPtrWillBeRawPtr<Node> endNode, PassRefPtrWillBeRawPtr<Element> elementToInsert, EditingState* editingState)
+void ApplyStyleCommand::surroundNodeRangeWithElement(RawPtr<Node> passedStartNode, RawPtr<Node> endNode, RawPtr<Element> elementToInsert, EditingState* editingState)
 {
     ASSERT(passedStartNode);
     ASSERT(endNode);
     ASSERT(elementToInsert);
-    RefPtrWillBeRawPtr<Node> node = passedStartNode;
-    RefPtrWillBeRawPtr<Element> element = elementToInsert;
+    RawPtr<Node> node = passedStartNode;
+    RawPtr<Element> element = elementToInsert;
 
     insertNodeBefore(element, node, editingState);
     if (editingState->isAborted())
         return;
 
     while (node) {
-        RefPtrWillBeRawPtr<Node> next = node->nextSibling();
+        RawPtr<Node> next = node->nextSibling();
         if (node->isContentEditable(Node::UserSelectAllIsAlwaysNonEditable)) {
             removeNode(node, editingState);
             if (editingState->isAborted())
                 return;
             appendNode(node, element, editingState);
             if (editingState->isAborted())
                 return;
         }
         if (node == endNode)
             break;
         node = next;
     }
 
-    RefPtrWillBeRawPtr<Node> nextSibling = element->nextSibling();
-    RefPtrWillBeRawPtr<Node> previousSibling = element->previousSibling();
+    RawPtr<Node> nextSibling = element->nextSibling();
+    RawPtr<Node> previousSibling = element->previousSibling();
     if (nextSibling && nextSibling->isElementNode() && nextSibling->hasEditableStyle()
         && areIdenticalElements(*element, toElement(*nextSibling))) {
         mergeIdenticalElements(element.get(), toElement(nextSibling), editingState);
         if (editingState->isAborted())
             return;
     }
 
     if (previousSibling && previousSibling->isElementNode() && previousSibling->hasEditableStyle()) {
         Node* mergedElement = previousSibling->nextSibling();
         if (mergedElement->isElementNode() && mergedElement->hasEditableStyle()
@@ skipping 20 matching lines @@
     StringBuilder cssText;
     cssText.append(cssStyle);
     if (const StylePropertySet* decl = block->inlineStyle()) {
         if (!cssStyle.isEmpty())
             cssText.append(' ');
         cssText.append(decl->asText());
     }
     setNodeAttribute(block, styleAttr, cssText.toAtomicString());
 }
 
-void ApplyStyleCommand::addInlineStyleIfNeeded(EditingStyle* style, PassRefPtrWillBeRawPtr<Node> passedStart, PassRefPtrWillBeRawPtr<Node> passedEnd, EditingState* editingState)
+void ApplyStyleCommand::addInlineStyleIfNeeded(EditingStyle* style, RawPtr<Node> passedStart, RawPtr<Node> passedEnd, EditingState* editingState)
 {
     if (!passedStart || !passedEnd || !passedStart->inDocument() || !passedEnd->inDocument())
         return;
 
-    RefPtrWillBeRawPtr<Node> start = passedStart;
-    RefPtrWillBeMember<HTMLSpanElement> dummyElement = nullptr;
+    RawPtr<Node> start = passedStart;
+    Member<HTMLSpanElement> dummyElement = nullptr;
     StyleChange styleChange(style, positionToComputeInlineStyleChange(start, dummyElement, editingState));
     if (editingState->isAborted())
         return;
 
     if (dummyElement) {
         removeNode(dummyElement, editingState);
         if (editingState->isAborted())
             return;
     }
 
     applyInlineStyleChange(start, passedEnd, styleChange, DoNotAddStyledElement, editingState);
 }
 
-Position ApplyStyleCommand::positionToComputeInlineStyleChange(PassRefPtrWillBeRawPtr<Node> startNode, RefPtrWillBeMember<HTMLSpanElement>& dummyElement, EditingState* editingState)
+Position ApplyStyleCommand::positionToComputeInlineStyleChange(RawPtr<Node> startNode, Member<HTMLSpanElement>& dummyElement, EditingState* editingState)
 {
     // It's okay to obtain the style at the startNode because we've removed all relevant styles from the current run.
     if (!startNode->isElementNode()) {
         dummyElement = HTMLSpanElement::create(document());
         insertNodeAt(dummyElement, positionBeforeNode(startNode.get()), editingState);
         if (editingState->isAborted())
             return Position();
         return positionBeforeNode(dummyElement.get());
     }
 
     return firstPositionInOrBeforeNode(startNode.get());
 }
 
-void ApplyStyleCommand::applyInlineStyleChange(PassRefPtrWillBeRawPtr<Node> passedStart, PassRefPtrWillBeRawPtr<Node> passedEnd, StyleChange& styleChange, EAddStyledElement addStyledElement, EditingState* editingState)
+void ApplyStyleCommand::applyInlineStyleChange(RawPtr<Node> passedStart, RawPtr<Node> passedEnd, StyleChange& styleChange, EAddStyledElement addStyledElement, EditingState* editingState)
 {
-    RefPtrWillBeRawPtr<Node> startNode = passedStart;
-    RefPtrWillBeRawPtr<Node> endNode = passedEnd;
+    RawPtr<Node> startNode = passedStart;
+    RawPtr<Node> endNode = passedEnd;
     ASSERT(startNode->inDocument());
     ASSERT(endNode->inDocument());
 
     // Find appropriate font and span elements top-down.
     HTMLFontElement* fontContainer = nullptr;
     HTMLElement* styleContainer = nullptr;
     for (Node* container = startNode.get(); container && startNode == endNode; container = container->firstChild()) {
         if (isHTMLFontElement(*container))
             fontContainer = toHTMLFontElement(container);
         bool styleContainerIsNotSpan = !isHTMLSpanElement(styleContainer);
@@ skipping 11 matching lines @@
     // Font tags need to go outside of CSS so that CSS font sizes override leagcy font sizes.
     if (styleChange.applyFontColor() || styleChange.applyFontFace() || styleChange.applyFontSize()) {
         if (fontContainer) {
             if (styleChange.applyFontColor())
                 setNodeAttribute(fontContainer, colorAttr, AtomicString(styleChange.fontColor()));
             if (styleChange.applyFontFace())
                 setNodeAttribute(fontContainer, faceAttr, AtomicString(styleChange.fontFace()));
             if (styleChange.applyFontSize())
                 setNodeAttribute(fontContainer, sizeAttr, AtomicString(styleChange.fontSize()));
         } else {
-            RefPtrWillBeRawPtr<HTMLFontElement> fontElement = HTMLFontElement::create(document());
+            RawPtr<HTMLFontElement> fontElement = HTMLFontElement::create(document());
             if (styleChange.applyFontColor())
                 fontElement->setAttribute(colorAttr, AtomicString(styleChange.fontColor()));
             if (styleChange.applyFontFace())
                 fontElement->setAttribute(faceAttr, AtomicString(styleChange.fontFace()));
             if (styleChange.applyFontSize())
                 fontElement->setAttribute(sizeAttr, AtomicString(styleChange.fontSize()));
             surroundNodeRangeWithElement(startNode, endNode, fontElement.get(), editingState);
             if (editingState->isAborted())
                 return;
         }
     }
 
     if (styleChange.cssStyle().length()) {
         if (styleContainer) {
             if (const StylePropertySet* existingStyle = styleContainer->inlineStyle()) {
                 String existingText = existingStyle->asText();
                 StringBuilder cssText;
                 cssText.append(existingText);
                 if (!existingText.isEmpty())
                     cssText.append(' ');
                 cssText.append(styleChange.cssStyle());
                 setNodeAttribute(styleContainer, styleAttr, cssText.toAtomicString());
             } else {
                 setNodeAttribute(styleContainer, styleAttr, AtomicString(styleChange.cssStyle()));
             }
         } else {
-            RefPtrWillBeRawPtr<HTMLSpanElement> styleElement = HTMLSpanElement::create(document());
+            RawPtr<HTMLSpanElement> styleElement = HTMLSpanElement::create(document());
             styleElement->setAttribute(styleAttr, AtomicString(styleChange.cssStyle()));
             surroundNodeRangeWithElement(startNode, endNode, styleElement.release(), editingState);
             if (editingState->isAborted())
                 return;
         }
     }
 
     if (styleChange.applyBold()) {
         surroundNodeRangeWithElement(startNode, endNode, HTMLElement::create(bTag, document()), editingState);
         if (editingState->isAborted())
@@ skipping 30 matching lines @@
 
     if (m_styledInlineElement && addStyledElement == AddStyledElement)
         surroundNodeRangeWithElement(startNode, endNode, m_styledInlineElement->cloneElementWithoutChildren(), editingState);
 }
 
 float ApplyStyleCommand::computedFontSize(Node* node)
 {
     if (!node)
         return 0;
 
-    RefPtrWillBeRawPtr<CSSComputedStyleDeclaration> style = CSSComputedStyleDeclaration::create(node);
+    RawPtr<CSSComputedStyleDeclaration> style = CSSComputedStyleDeclaration::create(node);
     if (!style)
         return 0;
 
-    RefPtrWillBeRawPtr<CSSPrimitiveValue> value = static_pointer_cast<CSSPrimitiveValue>(style->getPropertyCSSValue(CSSPropertyFontSize));
+    RawPtr<CSSPrimitiveValue> value = static_pointer_cast<CSSPrimitiveValue>(style->getPropertyCSSValue(CSSPropertyFontSize));
     if (!value)
         return 0;
 
     ASSERT(value->typeWithCalcResolved() == CSSPrimitiveValue::UnitType::Pixels);
     return value->getFloatValue();
 }
 
 void ApplyStyleCommand::joinChildTextNodes(ContainerNode* node, const Position& start, const Position& end)
 {
     if (!node)
         return;
 
     Position newStart = start;
     Position newEnd = end;
 
-    WillBeHeapVector<RefPtrWillBeMember<Text>> textNodes;
+    HeapVector<Member<Text>> textNodes;
     for (Node* curr = node->firstChild(); curr; curr = curr->nextSibling()) {
         if (!curr->isTextNode())
             continue;
 
         textNodes.append(toText(curr));
     }
 
     for (const auto& textNode : textNodes) {
         Text* childText = textNode.get();
         Node* next = childText->nextSibling();
@@ skipping 18 matching lines @@
 DEFINE_TRACE(ApplyStyleCommand)
 {
     visitor->trace(m_style);
     visitor->trace(m_start);
     visitor->trace(m_end);
     visitor->trace(m_styledInlineElement);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink