Rename inDocument() to inShadowIncludingDocument()

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 771 matching lines @@
     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();
+        return start && end && start->inShadowIncludingDocument() && end->inShadowIncludingDocument();
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(start);
         visitor->trace(end);
         visitor->trace(pastEndNode);
         visitor->trace(positionForStyleComputation);
         visitor->trace(dummyElement);
     }
@@ skipping 126 matching lines @@
         if (m_styledInlineElement && !enclosingElementWithTag(positionBeforeNode(node), m_styledInlineElement->tagQName()))
             return true;
     }
     return false;
 }
 
 void ApplyStyleCommand::removeConflictingInlineStyleFromRun(EditingStyle* style, Member<Node>& runStart, Member<Node>& runEnd, RawPtr<Node> pastEndNode, EditingState* editingState)
 {
     ASSERT(runStart && runEnd);
     RawPtr<Node> next = runStart;
-    for (RawPtr<Node> node = next; node && node->inDocument() && node != pastEndNode; node = next) {
+    for (RawPtr<Node> node = next; node && node->inShadowIncludingDocument() && 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);
         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()) {
+        if (!element.inShadowIncludingDocument()) {
             // 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, RawPtr<HTMLElement> element, EditingState* editingState, InlineStyleRemovalMode mode, EditingStyle* extractedStyle)
@@ skipping 11 matching lines @@
         removeNodePreservingChildren(element, editingState);
         if (editingState->isAborted())
             return false;
         return true;
     }
 
     bool removed = removeImplicitlyStyledElement(style, element.get(), mode, extractedStyle, editingState);
     if (editingState->isAborted())
         return false;
 
-    if (!element->inDocument())
+    if (!element->inShadowIncludingDocument())
         return removed;
 
     // If the node was converted to a span, the span may still contain relevant
     // styles which must be removed (e.g. <b style='font-weight: bold'>)
     if (removeCSSStyle(style, element.get(), editingState, mode, extractedStyle))
         removed = true;
     if (editingState->isAborted())
         return false;
 
     return removed;
@@ skipping 174 matching lines @@
             if (child == targetNode || child->contains(targetNode))
                 current = child;
         }
     }
 }
 
 void ApplyStyleCommand::removeInlineStyle(EditingStyle* style, const Position &start, const Position &end, EditingState* editingState)
 {
     ASSERT(start.isNotNull());
     ASSERT(end.isNotNull());
-    ASSERT(start.inDocument());
-    ASSERT(end.inDocument());
+    ASSERT(start.inShadowIncludingDocument());
+    ASSERT(end.inShadowIncludingDocument());
     ASSERT(Position::commonAncestorTreeScope(start, end));
     ASSERT(comparePositions(start, end) <= 0);
     // FIXME: We should assert that start/end are not in the middle of a text node.
 
     Position pushDownStart = mostForwardCaretPosition(start);
     // If the pushDownStart is at the end of a text node, then this node is not fully selected.
     // Move it to the next deep quivalent position to avoid removing the style from this node.
     // e.g. if pushDownStart was at Position("hello", 5) in <b>hello<div>world</div></b>, we want Position("world", 0) instead.
     Node* pushDownStartContainer = pushDownStart.computeContainerNode();
     if (pushDownStartContainer && pushDownStartContainer->isTextNode()
@@ skipping 42 matching lines @@
             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 (!elem->inShadowIncludingDocument()) {
                 if (s.anchorNode() == 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.
                     ASSERT(s.isBeforeAnchor() || s.isBeforeChildren() || s.offsetInContainerNode() <= 0);
                     s = firstPositionInOrBeforeNode(next.get());
                 }
                 if (e.anchorNode() == elem) {
                     // Since elem must have been fully selected, and it is at the end
                     // of the selection, it is clear we can set the new e offset to
                     // the max range offset of prev.
@@ skipping 251 matching lines @@
     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, RawPtr<Node> passedStart, RawPtr<Node> passedEnd, EditingState* editingState)
 {
-    if (!passedStart || !passedEnd || !passedStart->inDocument() || !passedEnd->inDocument())
+    if (!passedStart || !passedEnd || !passedStart->inShadowIncludingDocument() || !passedEnd->inShadowIncludingDocument())
         return;
 
     RawPtr<Node> start = passedStart;
     Member<HTMLSpanElement> dummyElement = nullptr;
     StyleChange styleChange(style, positionToComputeInlineStyleChange(start, dummyElement, editingState));
     if (editingState->isAborted())
         return;
 
     if (dummyElement) {
         removeNode(dummyElement, editingState);
@@ skipping 15 matching lines @@
         return positionBeforeNode(dummyElement.get());
     }
 
     return firstPositionInOrBeforeNode(startNode.get());
 }
 
 void ApplyStyleCommand::applyInlineStyleChange(RawPtr<Node> passedStart, RawPtr<Node> passedEnd, StyleChange& styleChange, EAddStyledElement addStyledElement, EditingState* editingState)
 {
     RawPtr<Node> startNode = passedStart;
     RawPtr<Node> endNode = passedEnd;
-    ASSERT(startNode->inDocument());
-    ASSERT(endNode->inDocument());
+    ASSERT(startNode->inShadowIncludingDocument());
+    ASSERT(endNode->inShadowIncludingDocument());
 
     // 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);
         if (container->isHTMLElement()) {
             HTMLElement* containerElement = toHTMLElement(container);
@@ skipping 146 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