Rename Node::inShadowIncludingDocument() to Node::isConnected()

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 786 matching lines @@
     InlineRunToApplyStyle(Node* start, Node* end, Node* pastEndNode)
         : start(start)
         , end(end)
         , pastEndNode(pastEndNode)
     {
         DCHECK_EQ(start->parentNode(), end->parentNode());
     }
 
     bool startAndEndAreStillInDocument()
     {
-        return start && end && start->inShadowIncludingDocument() && end->inShadowIncludingDocument();
+        return start && end && start->isConnected() && end->isConnected();
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(start);
         visitor->trace(end);
         visitor->trace(pastEndNode);
         visitor->trace(positionForStyleComputation);
         visitor->trace(dummyElement);
     }
@@ skipping 128 matching lines @@
             return true;
     }
     return false;
 }
 
 void ApplyStyleCommand::removeConflictingInlineStyleFromRun(EditingStyle* style, Member<Node>& runStart, Member<Node>& runEnd, Node* pastEndNode, EditingState* editingState)
 {
     DCHECK(runStart);
     DCHECK(runEnd);
     Node* next = runStart;
-    for (Node* node = next; node && node->inShadowIncludingDocument() && node != pastEndNode; node = next) {
+    for (Node* node = next; node && node->isConnected() && node != pastEndNode; node = next) {
         if (editingIgnoresContent(node)) {
             DCHECK(!node->contains(pastEndNode)) << node << " " << pastEndNode;
             next = NodeTraversal::nextSkippingChildren(*node);
         } else {
             next = NodeTraversal::next(*node);
         }
         if (!node->isHTMLElement())
             continue;
 
         HTMLElement& element = toHTMLElement(*node);
         Node* previousSibling = element.previousSibling();
         Node* nextSibling = element.nextSibling();
         ContainerNode* parent = element.parentNode();
         removeInlineStyleFromElement(style, &element, editingState, RemoveAlways);
         if (editingState->isAborted())
             return;
-        if (!element.inShadowIncludingDocument()) {
+        if (!element.isConnected()) {
             // 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, 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, mode, extractedStyle, editingState);
     if (editingState->isAborted())
         return false;
 
-    if (!element->inShadowIncludingDocument())
+    if (!element->isConnected())
         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, 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)
 {
     DCHECK(start.isNotNull());
     DCHECK(end.isNotNull());
-    DCHECK(start.inShadowIncludingDocument()) << start;
-    DCHECK(end.inShadowIncludingDocument()) << end;
+    DCHECK(start.isConnected()) << start;
+    DCHECK(end.isConnected()) << end;
     DCHECK(Position::commonAncestorTreeScope(start, end)) << start << " " << end;
     DCHECK_LE(start, end);
     // 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 @@
             EditingStyle* styleToPushDown = nullptr;
             Node* childNode = nullptr;
             if (isStyledInlineElementToRemove(elem)) {
                 styleToPushDown = EditingStyle::create();
                 childNode = elem->firstChild();
             }
 
             removeInlineStyleFromElement(style, elem, editingState, RemoveIfNeeded, styleToPushDown);
             if (editingState->isAborted())
                 return;
-            if (!elem->inShadowIncludingDocument()) {
+            if (!elem->isConnected()) {
                 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.
                     DCHECK(s.isBeforeAnchor() || s.isBeforeChildren() || s.offsetInContainerNode() <= 0) << s;
                     s = firstPositionInOrBeforeNode(next);
                 }
                 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, Node* passedStart, Node* passedEnd, EditingState* editingState)
 {
-    if (!passedStart || !passedEnd || !passedStart->inShadowIncludingDocument() || !passedEnd->inShadowIncludingDocument())
+    if (!passedStart || !passedEnd || !passedStart->isConnected() || !passedEnd->isConnected())
         return;
 
     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 Position::beforeNode(dummyElement);
     }
 
     return firstPositionInOrBeforeNode(startNode);
 }
 
 void ApplyStyleCommand::applyInlineStyleChange(Node* passedStart, Node* passedEnd, StyleChange& styleChange, EAddStyledElement addStyledElement, EditingState* editingState)
 {
     Node* startNode = passedStart;
     Node* endNode = passedEnd;
-    DCHECK(startNode->inShadowIncludingDocument()) << startNode;
-    DCHECK(endNode->inShadowIncludingDocument()) << endNode;
+    DCHECK(startNode->isConnected()) << startNode;
+    DCHECK(endNode->isConnected()) << endNode;
 
     // Find appropriate font and span elements top-down.
     HTMLFontElement* fontContainer = nullptr;
     HTMLElement* styleContainer = nullptr;
     for (Node* container = startNode; container && startNode == endNode; container = container->firstChild()) {
         if (isHTMLFontElement(*container))
             fontContainer = toHTMLFontElement(container);
         bool styleContainerIsNotSpan = !isHTMLSpanElement(styleContainer);
         if (container->isHTMLElement()) {
             HTMLElement* containerElement = toHTMLElement(container);
@@ skipping 147 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