Have StyledMarkupSerializer work on the Composed tree

Source/core/editing/StyledMarkupSerializer.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009, 2010, 2011 Google Inc. All rights reserved.
  * Copyright (C) 2011 Igalia S.L.
  * Copyright (C) 2011 Motorola Mobility. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 41 matching lines @@
 {
     if (position.isNull())
         return TextOffset();
 
     if (!position.containerNode()->isTextNode())
         return TextOffset();
 
     return TextOffset(toText(position.containerNode()), position.offsetInContainerNode());
 }
 
+template<typename EditingStrategy>
+static bool handleSelectionBoundary(const Node&);
+
+template<>
+bool handleSelectionBoundary<EditingStrategy>(const Node&)
+{
+    return false;
+}
+
+template<>
+bool handleSelectionBoundary<EditingInComposedTreeStrategy>(const Node& node)
+{
+    return EditingInComposedTreeStrategy::isSelectionBoundaryShadowHost(node);
+}
+
 } // namespace
 
 using namespace HTMLNames;
 
 template<typename Strategy>
 class StyledMarkupTraverser {
     WTF_MAKE_NONCOPYABLE(StyledMarkupTraverser);
     STACK_ALLOCATED();
 public:
     StyledMarkupTraverser();
@@ skipping 195 matching lines @@
     Node* lastClosed = nullptr;
     for (Node* n = startNode; n != pastEnd; n = next) {
         // According to <rdar://problem/5730668>, it is possible for n to blow
         // past pastEnd and become null here. This shouldn't be possible.
         // This null check will prevent crashes (but create too much markup)
         // and the ASSERT will hopefully lead us to understanding the problem.
         ASSERT(n);
         if (!n)
             break;
 
-        next = Strategy::next(*n);
-
-        if (isBlock(n) && canHaveChildrenForEditing(n) && next == pastEnd) {
-            // Don't write out empty block containers that aren't fully selected.
-            continue;
-        }
-
-        if (!n->layoutObject() && !enclosingElementWithTag(firstPositionInOrBeforeNode(n), selectTag)) {
-            next = Strategy::nextSkippingChildren(*n);
-            // Don't skip over pastEnd.
-            if (pastEnd && Strategy::isDescendantOf(*pastEnd, *n))
-                next = pastEnd;
+        // If |n| is a selection boundary such as <input>, traverse the child
+        // nodes in the DOM tree instead of the composed tree.
+        if (handleSelectionBoundary<Strategy>(*n)) {
+            lastClosed = StyledMarkupTraverser<EditingStrategy>(m_accumulator, m_lastClosed.get()).traverse(n, EditingStrategy::nextSkippingChildren(*n));
+            next = EditingInComposedTreeStrategy::nextSkippingChildren(*n);
         } else {
-            // Add the node to the markup if we're not skipping the descendants
-            appendStartMarkup(*n);
-
-            // If node has no children, close the tag now.
-            if (Strategy::hasChildren(*n)) {
-                ancestorsToClose.append(toContainerNode(n));
+            next = Strategy::next(*n);
+            if (isBlock(n) && canHaveChildrenForEditing(n) && next == pastEnd) {
+                // Don't write out empty block containers that aren't fully selected.
                 continue;
             }
-            appendEndMarkup(*n);
-            lastClosed = n;
+
+            if (!n->layoutObject() && !enclosingElementWithTag(firstPositionInOrBeforeNode(n), selectTag)) {
+                next = Strategy::nextSkippingChildren(*n);
+                // Don't skip over pastEnd.
+                if (pastEnd && Strategy::isDescendantOf(*pastEnd, *n))
+                    next = pastEnd;
+            } else {
+                // Add the node to the markup if we're not skipping the descendants
+                appendStartMarkup(*n);
+
+                // If node has no children, close the tag now.
+                if (Strategy::hasChildren(*n)) {
+                    ancestorsToClose.append(toContainerNode(n));
+                    continue;
+                }
+                appendEndMarkup(*n);
+                lastClosed = n;
+            }
         }
 
         // If we didn't insert open tag and there's no more siblings or we're at the end of the traversal, take care of ancestors.
         // FIXME: What happens if we just inserted open tag and reached the end?
         if (Strategy::nextSibling(*n) && next != pastEnd)
             continue;
 
         // Close up the ancestors.
         while (!ancestorsToClose.isEmpty()) {
             ContainerNode* ancestor = ancestorsToClose.last();
@@ skipping 145 matching lines @@
     if (element.isStyledElement() && element.inlineStyle())
         inlineStyle->overrideWithStyle(element.inlineStyle());
 
     if (element.isHTMLElement() && shouldAnnotate())
         inlineStyle->mergeStyleFromRulesForSerialization(&toHTMLElement(element));
 
     return inlineStyle;
 }
 
 template class StyledMarkupSerializer<EditingStrategy>;
+template class StyledMarkupSerializer<EditingInComposedTreeStrategy>;
 
 } // namespace blink