Oilpan: move editing objects to the heap.

Source/core/editing/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 88 matching lines @@
 }
 
 bool isEmptyFontTag(const Element* element, ShouldStyleAttributeBeEmpty shouldStyleAttributeBeEmpty)
 {
     if (!isHTMLFontElement(element))
         return false;
 
     return hasNoAttributeOrOnlyStyleAttribute(toHTMLElement(element), shouldStyleAttributeBeEmpty);
 }
 
-static PassRefPtr<Element> createFontElement(Document& document)
+static PassRefPtrWillBeRawPtr<Element> createFontElement(Document& document)
 {
-    RefPtr<Element> fontNode = createHTMLElement(document, fontTag);
+    RefPtrWillBeRawPtr<Element> fontNode = createHTMLElement(document, fontTag);
     return fontNode.release();
 }
 
 PassRefPtrWillBeRawPtr<HTMLElement> createStyleSpanElement(Document& document)
 {
     RefPtrWillBeRawPtr<HTMLElement> styleElement = createHTMLElement(document, spanTag);
     return styleElement.release();
 }
 
 ApplyStyleCommand::ApplyStyleCommand(Document& document, const EditingStyle* style, EditAction editingAction, EPropertyLevel propertyLevel)
@@ skipping 17 matching lines @@
     , m_propertyLevel(propertyLevel)
     , m_start(start)
     , m_end(end)
     , m_useEndingSelection(false)
     , m_styledInlineElement(nullptr)
     , m_removeOnly(false)
     , m_isInlineElementToRemoveFunction(0)
 {
 }
 
-ApplyStyleCommand::ApplyStyleCommand(PassRefPtr<Element> element, bool removeOnly, EditAction editingAction)
+ApplyStyleCommand::ApplyStyleCommand(PassRefPtrWillBeRawPtr<Element> element, bool removeOnly, EditAction editingAction)
     : CompositeEditCommand(element->document())
     , m_style(EditingStyle::create())
     , m_editingAction(editingAction)
     , m_propertyLevel(PropertyDefault)
     , m_start(endingSelection().start().downstream())
     , m_end(endingSelection().end().upstream())
     , 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()
 {
     switch (m_propertyLevel) {
     case PropertyDefault: {
         // Apply the block-centric properties of the style.
-        RefPtr<EditingStyle> blockStyle = m_style->extractAndRemoveBlockProperties();
+        RefPtrWillBeRawPtr<EditingStyle> blockStyle = m_style->extractAndRemoveBlockProperties();
         if (!blockStyle->isEmpty())
             applyBlockStyle(blockStyle.get());
         // Apply any remaining styles to the inline elements.
         if (!m_style->isEmpty() || m_styledInlineElement || m_isInlineElementToRemoveFunction) {
             applyRelativeFontStyleChange(m_style.get());
             applyInlineStyle(m_style.get());
         }
         break;
     }
     case ForceBlockProperties:
@@ skipping 38 matching lines @@
     RefPtrWillBeRawPtr<Range> endRange = Range::create(document(), firstPositionInNode(&scope), visibleEnd.deepEquivalent().parentAnchoredEquivalent());
     int startIndex = TextIterator::rangeLength(startRange.get(), true);
     int endIndex = TextIterator::rangeLength(endRange.get(), true);
 
     VisiblePosition paragraphStart(startOfParagraph(visibleStart));
     VisiblePosition nextParagraphStart(endOfParagraph(paragraphStart).next());
     VisiblePosition beyondEnd(endOfParagraph(visibleEnd).next());
     while (paragraphStart.isNotNull() && paragraphStart != beyondEnd) {
         StyleChange styleChange(style, paragraphStart.deepEquivalent());
         if (styleChange.cssStyle().length() || m_removeOnly) {
-            RefPtr<Node> block = enclosingBlock(paragraphStart.deepEquivalent().deprecatedNode());
+            RefPtrWillBeRawPtr<Node> block = enclosingBlock(paragraphStart.deepEquivalent().deprecatedNode());
             if (!m_removeOnly) {
-                RefPtr<Node> newBlock = moveParagraphContentsToNewBlockIfNecessary(paragraphStart.deepEquivalent());
+                RefPtrWillBeRawPtr<Node> newBlock = moveParagraphContentsToNewBlockIfNecessary(paragraphStart.deepEquivalent());
                 if (newBlock)
                     block = newBlock;
             }
             ASSERT(!block || block->isHTMLElement());
             if (block && block->isHTMLElement()) {
                 removeCSSStyle(style, toHTMLElement(block));
                 if (!m_removeOnly)
                     addBlockStyle(styleChange, toHTMLElement(block));
             }
 
@@ skipping 201 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.
-    RefPtr<Node> currentNode = node;
+    RefPtrWillBeRawPtr<Node> currentNode = node;
     while (currentNode) {
-        RefPtr<Element> parent = toElement(currentNode->parentNode());
+        RefPtrWillBeRawPtr<Element> parent = toElement(currentNode->parentNode());
         if (before ? currentNode->previousSibling() : currentNode->nextSibling())
-            splitElement(parent, before ? currentNode : currentNode->nextSibling());
+            splitElement(parent, before ? currentNode.get() : currentNode->nextSibling());
         if (parent == highestAncestorWithUnicodeBidi)
             break;
         currentNode = parent;
     }
     return unsplitAncestor;
 }
 
 void ApplyStyleCommand::removeEmbeddingUpToEnclosingBlock(Node* node, Node* unsplitAncestor)
 {
     Node* block = enclosingBlock(node);
@@ skipping 33 matching lines @@
     for (Node* n = startNode; n && n != enclosingNode; n = n->parentNode()) {
         if (n->isHTMLElement() && getIdentifierValue(CSSComputedStyleDeclaration::create(n).get(), CSSPropertyUnicodeBidi) == CSSValueEmbed)
             return n;
     }
 
     return 0;
 }
 
 void ApplyStyleCommand::applyInlineStyle(EditingStyle* style)
 {
-    RefPtr<Node> startDummySpanAncestor = nullptr;
-    RefPtr<Node> endDummySpanAncestor = nullptr;
+    RefPtrWillBeRawPtr<Node> startDummySpanAncestor = nullptr;
+    RefPtrWillBeRawPtr<Node> 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 31 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 = start.upstream();
     WritingDirection textDirection = NaturalWritingDirection;
     bool hasTextDirection = style->textDirection(textDirection);
-    RefPtr<EditingStyle> styleWithoutEmbedding;
-    RefPtr<EditingStyle> embeddingStyle;
+    RefPtrWillBeRawPtr<EditingStyle> styleWithoutEmbedding = nullptr;
+    RefPtrWillBeRawPtr<EditingStyle> embeddingStyle = nullptr;
     if (hasTextDirection) {
         // Leave alone an ancestor that provides the desired single level embedding, if there is one.
         HTMLElement* startUnsplitAncestor = splitAncestorsWithUnicodeBidi(start.deprecatedNode(), true, textDirection);
         HTMLElement* endUnsplitAncestor = splitAncestorsWithUnicodeBidi(end.deprecatedNode(), false, textDirection);
         removeEmbeddingUpToEnclosingBlock(start.deprecatedNode(), startUnsplitAncestor);
         removeEmbeddingUpToEnclosingBlock(end.deprecatedNode(), endUnsplitAncestor);
 
         // Avoid removing the dir attribute and the unicode-bidi and direction properties from the unsplit ancestors.
         Position embeddingRemoveStart = removeStart;
         if (startUnsplitAncestor && nodeFullySelected(startUnsplitAncestor, removeStart, end))
@@ skipping 27 matching lines @@
         mergeEndWithNextIfIdentical(start, end);
         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();
 
-    RefPtr<EditingStyle> styleToApply = style;
+    RefPtrWillBeRawPtr<EditingStyle> styleToApply = style;
     if (hasTextDirection) {
         // Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.
         Node* embeddingStartNode = highestEmbeddingAncestor(start.deprecatedNode(), enclosingBlock(start.deprecatedNode()));
         Node* embeddingEndNode = highestEmbeddingAncestor(end.deprecatedNode(), enclosingBlock(end.deprecatedNode()));
 
         if (embeddingStartNode || embeddingEndNode) {
             Position embeddingApplyStart = embeddingStartNode ? positionInParentAfterNode(*embeddingStartNode) : start;
             Position embeddingApplyEnd = embeddingEndNode ? positionInParentBeforeNode(*embeddingEndNode) : end;
             ASSERT(embeddingApplyStart.isNotNull() && embeddingApplyEnd.isNotNull());
 
@@ skipping 55 matching lines @@
 
     Node* sibling = NodeTraversal::nextSkippingChildren(node);
     for (Node* descendent = node.firstChild(); descendent && descendent != sibling; descendent = NodeTraversal::next(*descendent)) {
         if (!descendent->rendererIsEditable())
             return true;
     }
 
     return false;
 }
 
-struct InlineRunToApplyStyle {
+class InlineRunToApplyStyle {
+    ALLOW_ONLY_INLINE_ALLOCATION();
+public:
     InlineRunToApplyStyle(Node* start, Node* end, Node* pastEndNode)
         : start(start)
         , end(end)
         , pastEndNode(pastEndNode)
     {
         ASSERT(start->parentNode() == end->parentNode());
     }
 
     bool startAndEndAreStillInDocument()
     {
         return start && end && start->inDocument() && end->inDocument();
     }
 
-    RefPtr<Node> start;
-    RefPtr<Node> end;
-    RefPtr<Node> pastEndNode;
+    void trace(Visitor* visitor)
+    {
+        visitor->trace(start);
+        visitor->trace(end);
+        visitor->trace(pastEndNode);
+        visitor->trace(positionForStyleComputation);
+        visitor->trace(dummyElement);
+    }
+
+    RefPtrWillBeMember<Node> start;
+    RefPtrWillBeMember<Node> end;
+    RefPtrWillBeMember<Node> pastEndNode;
     Position positionForStyleComputation;
-    RefPtr<Node> dummyElement;
+    RefPtrWillBeMember<Node> dummyElement;
     StyleChange change;
 };
 
-void ApplyStyleCommand::applyInlineStyleToNodeRange(EditingStyle* style, PassRefPtr<Node> startNode, PassRefPtr<Node> pastEndNode)
+} // namespace WebCore
+
+WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(WebCore::InlineRunToApplyStyle);

[haraken, 2014/05/26 02:36:12]

I'm not sure if we can set canMoveWithMemcpy.

InlineRunToApplyStyle holds StyleChange which holds Strings. Given that Strings
need destructors to keep the reference counting of the underlying StringImpl
objects, I don't think canMoveWithMemcpy works correctly for
InlineRunToApplyStyle.

Also see my comment in markup.cpp.

[sof, 2014/05/28 08:31:35]

Yes, keeping this as a inline object won't work for that reason. Thanks for
checking all the fields here, which I didn't do.

Moved InlineRunToApplyStyle to the heap as a consequence.

+
+namespace WebCore {
+
+void ApplyStyleCommand::applyInlineStyleToNodeRange(EditingStyle* style, PassRefPtrWillBeRawPtr<Node> startNode, PassRefPtrWillBeRawPtr<Node> pastEndNode)
 {
     if (m_removeOnly)
         return;
 
     document().updateLayoutIgnorePendingStylesheets();
 
-    Vector<InlineRunToApplyStyle> runs;
-    RefPtr<Node> node = startNode;
-    for (RefPtr<Node> next; node && node != pastEndNode; node = next) {
+    WillBeHeapVector<InlineRunToApplyStyle> runs;
+    RefPtrWillBeRawPtr<Node> node = startNode;
+    for (RefPtrWillBeRawPtr<Node> next; node && node != pastEndNode; node = next) {
         next = NodeTraversal::next(*node);
 
         if (!node->renderer() || !node->rendererIsEditable())
             continue;
 
         if (!node->rendererIsRichlyEditable() && node->isHTMLElement()) {
             // 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(node.get()))
@@ skipping 77 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 && !enclosingNodeWithTag(positionBeforeNode(node), m_styledInlineElement->tagQName()))
             return true;
     }
     return false;
 }
 
-void ApplyStyleCommand::removeConflictingInlineStyleFromRun(EditingStyle* style, RefPtr<Node>& runStart, RefPtr<Node>& runEnd, PassRefPtr<Node> pastEndNode)
+void ApplyStyleCommand::removeConflictingInlineStyleFromRun(EditingStyle* style, RefPtrWillBeMember<Node>& runStart, RefPtrWillBeMember<Node>& runEnd, PassRefPtrWillBeRawPtr<Node> pastEndNode)
 {
     ASSERT(runStart && runEnd);
-    RefPtr<Node> next = runStart;
-    for (RefPtr<Node> node = next; node && node->inDocument() && node != pastEndNode; node = next) {
+    RefPtrWillBeRawPtr<Node> next = runStart;
+    for (RefPtrWillBeRawPtr<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;
 
-        RefPtr<Node> previousSibling = node->previousSibling();
-        RefPtr<Node> nextSibling = node->nextSibling();
-        RefPtr<ContainerNode> parent = node->parentNode();
+        RefPtrWillBeRawPtr<Node> previousSibling = node->previousSibling();
+        RefPtrWillBeRawPtr<Node> nextSibling = node->nextSibling();
+        RefPtrWillBeRawPtr<ContainerNode> parent = node->parentNode();
         removeInlineStyleFromElement(style, toHTMLElement(node), RemoveAlways);
         if (!node->inDocument()) {
             // FIXME: We might need to update the start and the end of current selection here but need a test.
             if (runStart == node)
                 runStart = previousSibling ? previousSibling->nextSibling() : parent->firstChild();
             if (runEnd == node)
                 runEnd = nextSibling ? nextSibling->previousSibling() : parent->lastChild();
         }
     }
 }
@@ skipping 110 matching lines @@
 
 void ApplyStyleCommand::applyInlineStyleToPushDown(Node* node, EditingStyle* style)
 {
     ASSERT(node);
 
     node->document().updateRenderTreeIfNeeded();
 
     if (!style || style->isEmpty() || !node->renderer() || isHTMLIFrameElement(*node))
         return;
 
-    RefPtr<EditingStyle> newInlineStyle = style;
+    RefPtrWillBeRawPtr<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 render objects, add style attribute instead.
     // FIXME: applyInlineStyleToRange should be used here instead.
     if ((node->renderer()->isRenderBlockFlow() || node->hasChildren()) && node->isHTMLElement()) {
         setNodeAttribute(toHTMLElement(node), styleAttr, AtomicString(newInlineStyle->style()->asText()));
         return;
     }
 
     if (node->renderer()->isText() && toRenderText(node->renderer())->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, DoNotAddStyledElement);
 }
 
 void ApplyStyleCommand::pushDownInlineStyleAroundNode(EditingStyle* style, Node* targetNode)
 {
     HTMLElement* highestAncestor = highestAncestorWithConflictingInlineStyle(style, targetNode);
     if (!highestAncestor)
         return;
 
     // The outer loop is traversing the tree vertically from highestAncestor to targetNode
-    RefPtr<Node> current = highestAncestor;
+    RefPtrWillBeRawPtr<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.
-    Vector<RefPtr<Element> > elementsToPushDown;
+    WillBeHeapVector<RefPtrWillBeMember<Element> > elementsToPushDown;
     while (current && current != targetNode && current->contains(targetNode)) {
         NodeVector currentChildren;
         getChildNodes(*current, currentChildren);
-        RefPtr<Element> styledElement;
+        RefPtrWillBeRawPtr<Element> styledElement = nullptr;
         if (current->isStyledElement() && isStyledInlineElementToRemove(toElement(current))) {
             styledElement = toElement(current);
             elementsToPushDown.append(styledElement);
         }
 
-        RefPtr<EditingStyle> styleToPushDown = EditingStyle::create();
+        RefPtrWillBeRawPtr<EditingStyle> styleToPushDown = EditingStyle::create();
         if (current->isHTMLElement())
             removeInlineStyleFromElement(style, toHTMLElement(current), RemoveIfNeeded, styleToPushDown.get());
 
         // 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 (size_t i = 0; i < currentChildren.size(); ++i) {
             Node* child = currentChildren[i].get();
             if (!child->parentNode())
                 continue;
             if (!child->contains(targetNode) && elementsToPushDown.size()) {
                 for (size_t i = 0; i < elementsToPushDown.size(); i++) {
-                    RefPtr<Element> wrapper = elementsToPushDown[i]->cloneElementWithoutChildren();
+                    RefPtrWillBeRawPtr<Element> wrapper = elementsToPushDown[i]->cloneElementWithoutChildren();
                     wrapper->removeAttribute(styleAttr);
                     surroundNodeRangeWithElement(child, child, wrapper);
                 }
             }
 
             // Apply style to all nodes containing targetNode and their siblings but NOT to targetNode
             // But if we've removed styledElement then go ahead and always apply the style.
             if (child != targetNode || styledElement)
                 applyInlineStyleToPushDown(child, styleToPushDown.get());
 
@@ skipping 33 matching lines @@
     pushDownInlineStyleAroundNode(style, pushDownEnd.deprecatedNode());
 
     // The s and e variables store the positions used to set the ending selection after style removal
     // takes place. This will help callers to recognize when either the start node or the end node
     // are removed from the document during the work of this function.
     // If pushDownInlineStyleAroundNode has pruned start.deprecatedNode() or end.deprecatedNode(),
     // 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;
 
-    RefPtr<Node> node = start.deprecatedNode();
+    RefPtrWillBeRawPtr<Node> node = start.deprecatedNode();
     while (node) {
-        RefPtr<Node> next;
+        RefPtrWillBeRawPtr<Node> next;

[haraken, 2014/05/26 02:36:12]

= nullptr

[sof, 2014/05/28 08:31:35]

Complied.

         if (editingIgnoresContent(node.get())) {
             ASSERT(node == end.deprecatedNode() || !node->contains(end.deprecatedNode()));
             next = NodeTraversal::nextSkippingChildren(*node);
         } else {
             next = NodeTraversal::next(*node);
         }
         if (node->isHTMLElement() && nodeFullySelected(node.get(), start, end)) {
             RefPtrWillBeRawPtr<HTMLElement> elem = toHTMLElement(node);
-            RefPtr<Node> prev = NodeTraversal::previousPostOrder(*elem);
-            RefPtr<Node> next = NodeTraversal::next(*elem);
-            RefPtr<EditingStyle> styleToPushDown;
-            RefPtr<Node> childNode;
+            RefPtrWillBeRawPtr<Node> prev = NodeTraversal::previousPostOrder(*elem);
+            RefPtrWillBeRawPtr<Node> next = NodeTraversal::next(*elem);
+            RefPtrWillBeRawPtr<EditingStyle> styleToPushDown = nullptr;
+            RefPtrWillBeRawPtr<Node> childNode = nullptr;
             if (isStyledInlineElementToRemove(elem.get())) {
                 styleToPushDown = EditingStyle::create();
                 childNode = elem->firstChild();
             }
 
             removeInlineStyleFromElement(style, elem.get(), RemoveIfNeeded, styleToPushDown.get());
             if (!elem->inDocument()) {
                 if (s.deprecatedNode() == elem) {
                     // Since elem must have been fully selected, and it is at the start
                     // of the selection, it is clear we can set the new s offset to 0.
@@ skipping 181 matching lines @@
         bool shouldUpdateStart = start.containerNode() == endNode;
         int endOffset = nextChild ? nextChild->nodeIndex() : nextElement->childNodes()->length();
         updateStartEnd(shouldUpdateStart ? Position(nextElement, start.offsetInContainerNode(), Position::PositionIsOffsetInAnchor) : start,
                        Position(nextElement, endOffset, Position::PositionIsOffsetInAnchor));
         return true;
     }
 
     return false;
 }
 
-void ApplyStyleCommand::surroundNodeRangeWithElement(PassRefPtr<Node> passedStartNode, PassRefPtr<Node> endNode, PassRefPtr<Element> elementToInsert)
+void ApplyStyleCommand::surroundNodeRangeWithElement(PassRefPtrWillBeRawPtr<Node> passedStartNode, PassRefPtrWillBeRawPtr<Node> endNode, PassRefPtrWillBeRawPtr<Element> elementToInsert)
 {
     ASSERT(passedStartNode);
     ASSERT(endNode);
     ASSERT(elementToInsert);
-    RefPtr<Node> node = passedStartNode;
-    RefPtr<Element> element = elementToInsert;
+    RefPtrWillBeRawPtr<Node> node = passedStartNode;
+    RefPtrWillBeRawPtr<Element> element = elementToInsert;
 
     insertNodeBefore(element, node);
 
     while (node) {
-        RefPtr<Node> next = node->nextSibling();
+        RefPtrWillBeRawPtr<Node> next = node->nextSibling();
         if (node->isContentEditable(Node::UserSelectAllIsAlwaysNonEditable)) {
             removeNode(node);
             appendNode(node, element);
         }
         if (node == endNode)
             break;
         node = next;
     }
 
-    RefPtr<Node> nextSibling = element->nextSibling();
-    RefPtr<Node> previousSibling = element->previousSibling();
+    RefPtrWillBeRawPtr<Node> nextSibling = element->nextSibling();
+    RefPtrWillBeRawPtr<Node> previousSibling = element->previousSibling();
     if (nextSibling && nextSibling->isElementNode() && nextSibling->rendererIsEditable()
         && areIdenticalElements(element.get(), toElement(nextSibling)))
         mergeIdenticalElements(element.get(), toElement(nextSibling));
 
     if (previousSibling && previousSibling->isElementNode() && previousSibling->rendererIsEditable()) {
         Node* mergedElement = previousSibling->nextSibling();
         if (mergedElement->isElementNode() && mergedElement->rendererIsEditable()
             && areIdenticalElements(toElement(previousSibling), toElement(mergedElement)))
             mergeIdenticalElements(toElement(previousSibling), toElement(mergedElement));
     }
@@ skipping 14 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, PassRefPtr<Node> passedStart, PassRefPtr<Node> passedEnd, EAddStyledElement addStyledElement)
+void ApplyStyleCommand::addInlineStyleIfNeeded(EditingStyle* style, PassRefPtrWillBeRawPtr<Node> passedStart, PassRefPtrWillBeRawPtr<Node> passedEnd, EAddStyledElement addStyledElement)
 {
     if (!passedStart || !passedEnd || !passedStart->inDocument() || !passedEnd->inDocument())
         return;
 
-    RefPtr<Node> start = passedStart;
-    RefPtr<Node> dummyElement;
+    RefPtrWillBeRawPtr<Node> start = passedStart;
+    RefPtrWillBeMember<Node> dummyElement = nullptr;

[haraken, 2014/05/26 02:36:12]

This should be RefPtrWillBeRawPtr.

[zerny-chromium, 2014/05/26 07:51:08]

While I agree that a raw pointer would be more apt here, but the real/other use
is that the dummyElement in an output parameter to a slot allocated in the
collection. I'm not sure what the best solution is here.

[sof, 2014/05/28 08:31:35]

Yes, that's what brings about the Member use here. 

     StyleChange styleChange(style, positionToComputeInlineStyleChange(start, dummyElement));
 
     if (dummyElement)
         removeNode(dummyElement);
 
     applyInlineStyleChange(start, passedEnd, styleChange, addStyledElement);
 }
 
-Position ApplyStyleCommand::positionToComputeInlineStyleChange(PassRefPtr<Node> startNode, RefPtr<Node>& dummyElement)
+Position ApplyStyleCommand::positionToComputeInlineStyleChange(PassRefPtrWillBeRawPtr<Node> startNode, RefPtrWillBeMember<Node>& dummyElement)
 {
     // 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 = createStyleSpanElement(document());
         insertNodeAt(dummyElement, positionBeforeNode(startNode.get()));
         return positionBeforeNode(dummyElement.get());
     }
 
     return firstPositionInOrBeforeNode(startNode.get());
 }
 
-void ApplyStyleCommand::applyInlineStyleChange(PassRefPtr<Node> passedStart, PassRefPtr<Node> passedEnd, StyleChange& styleChange, EAddStyledElement addStyledElement)
+void ApplyStyleCommand::applyInlineStyleChange(PassRefPtrWillBeRawPtr<Node> passedStart, PassRefPtrWillBeRawPtr<Node> passedEnd, StyleChange& styleChange, EAddStyledElement addStyledElement)
 {
-    RefPtr<Node> startNode = passedStart;
-    RefPtr<Node> endNode = passedEnd;
+    RefPtrWillBeRawPtr<Node> startNode = passedStart;
+    RefPtrWillBeRawPtr<Node> endNode = passedEnd;
     ASSERT(startNode->inDocument());
     ASSERT(endNode->inDocument());
 
     // Find appropriate font and span elements top-down.
     HTMLElement* fontContainer = 0;
     HTMLElement* styleContainer = 0;
     for (Node* container = startNode.get(); container && startNode == endNode; container = container->firstChild()) {
         if (isHTMLFontElement(*container))
             fontContainer = toHTMLElement(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 {
-            RefPtr<Element> fontElement = createFontElement(document());
+            RefPtrWillBeRawPtr<Element> fontElement = createFontElement(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());
         }
     }
 
     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 {
-            RefPtr<Element> styleElement = createStyleSpanElement(document());
+            RefPtrWillBeRawPtr<Element> styleElement = createStyleSpanElement(document());
             styleElement->setAttribute(styleAttr, AtomicString(styleChange.cssStyle()));
             surroundNodeRangeWithElement(startNode, endNode, styleElement.release());
         }
     }
 
     if (styleChange.applyBold())
         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), bTag));
 
     if (styleChange.applyItalic())
         surroundNodeRangeWithElement(startNode, endNode, createHTMLElement(document(), iTag));
@@ skipping 58 matching lines @@
             newEnd = Position(childText, childText->length() + end.offsetInContainerNode());
         String textToMove = nextText->data();
         insertTextIntoNode(childText, childText->length(), textToMove);
         removeNode(next);
         // don't move child node pointer. it may want to merge with more text nodes.
     }
 
     updateStartEnd(newStart, newEnd);
 }
 
+void ApplyStyleCommand::trace(Visitor* visitor)
+{
+    visitor->trace(m_style);
+    visitor->trace(m_styledInlineElement);
+    CompositeEditCommand::trace(visitor);
 }
+
+}