Reflow comments in //third_party/WebKit/Sourcecore/editing/serializers

third_party/WebKit/Source/core/editing/serializers/StyledMarkupSerializer.cpp

 /*
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * 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
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 121 matching lines @@
       m_lastClosed(highestNodeToBeSerialized) {}
 
 template <typename Strategy>
 static bool needInterchangeNewlineAfter(
     const VisiblePositionTemplate<Strategy>& v) {
   const VisiblePositionTemplate<Strategy> next = nextPositionOf(v);
   Node* upstreamNode =
       mostBackwardCaretPosition(next.deepEquivalent()).anchorNode();
   Node* downstreamNode =
       mostForwardCaretPosition(v.deepEquivalent()).anchorNode();
-  // Add an interchange newline if a paragraph break is selected and a br won't already be added to the markup to represent it.
+  // Add an interchange newline if a paragraph break is selected and a br won't
+  // already be added to the markup to represent it.
   return isEndOfParagraph(v) && isStartOfParagraph(next) &&
          !(isHTMLBRElement(*upstreamNode) && upstreamNode == downstreamNode);
 }
 
 template <typename Strategy>
 static bool needInterchangeNewlineAt(
     const VisiblePositionTemplate<Strategy>& v) {
   return needInterchangeNewlineAfter(previousPositionOf(v));
 }
 
 template <typename Strategy>
 static bool areSameRanges(Node* node,
                           const PositionTemplate<Strategy>& startPosition,
                           const PositionTemplate<Strategy>& endPosition) {
   DCHECK(node);
   const EphemeralRange range =
       VisibleSelection::selectionFromContentsOfNode(node)
           .toNormalizedEphemeralRange();
   return toPositionInDOMTree(startPosition) == range.startPosition() &&
          toPositionInDOMTree(endPosition) == range.endPosition();
 }
 
 static EditingStyle* styleFromMatchedRulesAndInlineDecl(
     const HTMLElement* element) {
   EditingStyle* style = EditingStyle::create(element->inlineStyle());
-  // FIXME: Having to const_cast here is ugly, but it is quite a bit of work to untangle
-  // the non-const-ness of styleFromMatchedRulesForElement.
+  // FIXME: Having to const_cast here is ugly, but it is quite a bit of work to
+  // untangle the non-const-ness of styleFromMatchedRulesForElement.
   style->mergeStyleFromRules(const_cast<HTMLElement*>(element));
   return style;
 }
 
 template <typename Strategy>
 String StyledMarkupSerializer<Strategy>::createMarkup() {
   StyledMarkupAccumulator markupAccumulator(
       m_shouldResolveURLs, toTextOffset(m_start.parentAnchoredEquivalent()),
       toTextOffset(m_end.parentAnchoredEquivalent()), m_start.document(),
       m_shouldAnnotate, m_convertBlocksToInlines);
@@ skipping 14 matching lines @@
     firstNode = nextPositionOf(visibleStart).deepEquivalent().anchorNode();
 
     if (pastEnd &&
         PositionTemplate<Strategy>::beforeNode(firstNode).compareTo(
             PositionTemplate<Strategy>::beforeNode(pastEnd)) >= 0) {
       // This condition hits in editing/pasteboard/copy-display-none.html.
       return markupAccumulator.takeResults();
     }
   }
 
-  // If there is no the highest node in the selected nodes, |m_lastClosed| can be #text
-  // when its parent is a formatting tag. In this case, #text is wrapped by <span> tag,
-  // but this text should be wrapped by the formatting tag. See http://crbug.com/634482
+  // If there is no the highest node in the selected nodes, |m_lastClosed| can
+  // be #text when its parent is a formatting tag. In this case, #text is
+  // wrapped by <span> tag, but this text should be wrapped by the formatting
+  // tag. See http://crbug.com/634482
   bool shouldAppendParentTag = false;
   if (!m_lastClosed) {
     m_lastClosed =
         StyledMarkupTraverser<Strategy>().traverse(firstNode, pastEnd);
     if (m_lastClosed && m_lastClosed->isTextNode() &&
         isPresentationalHTMLElement(m_lastClosed->parentNode())) {
       m_lastClosed = m_lastClosed->parentElement();
       shouldAppendParentTag = true;
     }
   }
 
   StyledMarkupTraverser<Strategy> traverser(&markupAccumulator, m_lastClosed);
   Node* lastClosed = traverser.traverse(firstNode, pastEnd);
 
   if (m_highestNodeToBeSerialized && lastClosed) {
     // TODO(hajimehoshi): This is calculated at createMarkupInternal too.
     Node* commonAncestor = Strategy::commonAncestor(
         *m_start.computeContainerNode(), *m_end.computeContainerNode());
     DCHECK(commonAncestor);
     HTMLBodyElement* body = toHTMLBodyElement(enclosingElementWithTag(
         Position::firstPositionInNode(commonAncestor), bodyTag));
     HTMLBodyElement* fullySelectedRoot = nullptr;
     // FIXME: Do this for all fully selected blocks, not just the body.
     if (body && areSameRanges(body, m_start, m_end))
       fullySelectedRoot = body;
 
-    // Also include all of the ancestors of lastClosed up to this special ancestor.
+    // Also include all of the ancestors of lastClosed up to this special
+    // ancestor.
     // FIXME: What is ancestor?
     for (ContainerNode* ancestor = Strategy::parent(*lastClosed); ancestor;
          ancestor = Strategy::parent(*ancestor)) {
       if (ancestor == fullySelectedRoot &&
           !markupAccumulator.convertBlocksToInlines()) {
         EditingStyle* fullySelectedRootStyle =
             styleFromMatchedRulesAndInlineDecl(fullySelectedRoot);
 
-        // Bring the background attribute over, but not as an attribute because a background attribute on a div
-        // appears to have no effect.
+        // Bring the background attribute over, but not as an attribute because
+        // a background attribute on a div appears to have no effect.
         if ((!fullySelectedRootStyle || !fullySelectedRootStyle->style() ||
              !fullySelectedRootStyle->style()->getPropertyCSSValue(
                  CSSPropertyBackgroundImage)) &&
             fullySelectedRoot->hasAttribute(backgroundAttr))
           fullySelectedRootStyle->style()->setProperty(
               CSSPropertyBackgroundImage,
               "url('" + fullySelectedRoot->getAttribute(backgroundAttr) + "')");
 
         if (fullySelectedRootStyle->style()) {
-          // Reset the CSS properties to avoid an assertion error in addStyleMarkup().
-          // This assertion is caused at least when we select all text of a <body> element whose
-          // 'text-decoration' property is "inherit", and copy it.
+          // Reset the CSS properties to avoid an assertion error in
+          // addStyleMarkup(). This assertion is caused at least when we select
+          // all text of a <body> element whose 'text-decoration' property is
+          // "inherit", and copy it.
           if (!propertyMissingOrEqualToNone(fullySelectedRootStyle->style(),
                                             CSSPropertyTextDecoration))
             fullySelectedRootStyle->style()->setProperty(
                 CSSPropertyTextDecoration, CSSValueNone);
           if (!propertyMissingOrEqualToNone(
                   fullySelectedRootStyle->style(),
                   CSSPropertyWebkitTextDecorationsInEffect))
             fullySelectedRootStyle->style()->setProperty(
                 CSSPropertyWebkitTextDecorationsInEffect, CSSValueNone);
           markupAccumulator.wrapWithStyleNode(fullySelectedRootStyle->style());
         }
       } else {
         EditingStyle* style = traverser.createInlineStyleIfNeeded(*ancestor);
-        // Since this node and all the other ancestors are not in the selection we want
-        // styles that affect the exterior of the node not to be not included.
-        // If the node is not fully selected by the range, then we don't want to keep styles that affect its relationship to the nodes around it
-        // only the ones that affect it and the nodes within it.
+        // Since this node and all the other ancestors are not in the selection
+        // we want styles that affect the exterior of the node not to be not
+        // included.  If the node is not fully selected by the range, then we
+        // don't want to keep styles that affect its relationship to the nodes
+        // around it only the ones that affect it and the nodes within it.
         if (style && style->style())
           style->style()->removeProperty(CSSPropertyFloat);
         traverser.wrapWithNode(*ancestor, style);
       }
 
       if (ancestor == m_highestNodeToBeSerialized)
         break;
     }
   } else if (shouldAppendParentTag) {
     EditingStyle* style = traverser.createInlineStyleIfNeeded(*m_lastClosed);
     traverser.wrapWithNode(*toContainerNode(m_lastClosed), style);
   }
 
-  // FIXME: The interchange newline should be placed in the block that it's in, not after all of the content, unconditionally.
+  // FIXME: The interchange newline should be placed in the block that it's in,
+  // not after all of the content, unconditionally.
   if (shouldAnnotate() && needInterchangeNewlineAt(visibleEnd))
     markupAccumulator.appendInterchangeNewline();
 
   return markupAccumulator.takeResults();
 }
 
 template <typename Strategy>
 StyledMarkupTraverser<Strategy>::StyledMarkupTraverser()
     : StyledMarkupTraverser(nullptr, nullptr) {}
 
@@ skipping 56 matching lines @@
         // 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.
+    // 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();
       DCHECK(ancestor);
       if (next && next != pastEnd && Strategy::isDescendantOf(*next, *ancestor))
         break;
-      // Not at the end of the range, close ancestors up to sibling of next node.
+      // Not at the end of the range, close ancestors up to sibling of next
+      // node.
       appendEndMarkup(*ancestor);
       lastClosed = ancestor;
       ancestorsToClose.removeLast();
     }
 
-    // Surround the currently accumulated markup with markup for ancestors we never opened as we leave the subtree(s) rooted at those ancestors.
+    // Surround the currently accumulated markup with markup for ancestors we
+    // never opened as we leave the subtree(s) rooted at those ancestors.
     ContainerNode* nextParent = next ? Strategy::parent(*next) : nullptr;
     if (next == pastEnd || n == nextParent)
       continue;
 
     DCHECK(n);
     Node* lastAncestorClosedOrSelf =
         (lastClosed && Strategy::isDescendantOf(*n, *lastClosed)) ? lastClosed
                                                                   : n;
     for (ContainerNode* parent = Strategy::parent(*lastAncestorClosedOrSelf);
          parent && parent != nextParent; parent = Strategy::parent(*parent)) {
-      // All ancestors that aren't in the ancestorsToClose list should either be a) unrendered:
+      // All ancestors that aren't in the ancestorsToClose list should either be
+      // a) unrendered:
       if (!parent->layoutObject())
         continue;
-      // or b) ancestors that we never encountered during a pre-order traversal starting at startNode:
+      // or b) ancestors that we never encountered during a pre-order traversal
+      // starting at startNode:
       DCHECK(startNode);
       DCHECK(Strategy::isDescendantOf(*startNode, *parent));
       EditingStyle* style = createInlineStyleIfNeeded(*parent);
       wrapWithNode(*parent, style);
       lastClosed = parent;
     }
   }
 
   return lastClosed;
 }
@@ skipping 49 matching lines @@
   switch (node.getNodeType()) {
     case Node::kTextNode: {
       Text& text = toText(node);
       if (text.parentElement() && isHTMLTextAreaElement(text.parentElement())) {
         m_accumulator->appendText(text);
         break;
       }
       EditingStyle* inlineStyle = nullptr;
       if (shouldApplyWrappingStyle(text)) {
         inlineStyle = m_wrappingStyle->copy();
-        // FIXME: <rdar://problem/5371536> Style rules that match pasted content can change it's appearance
-        // Make sure spans are inline style in paste side e.g. span { display: block }.
+        // FIXME: <rdar://problem/5371536> Style rules that match pasted content
+        // can change it's appearance.

[Nico, 2016/10/06 03:26:21]

nit: s/it's/its/

[dcheng, 2016/10/06 03:59:23]

Done.

+        // Make sure spans are inline style in paste side e.g. span { display:

[Nico, 2016/10/06 03:26:21]

nit: merge with previous line?

[dcheng, 2016/10/06 03:59:23]

As far as I can tell, this was a distinct FIXME:
https://chromium.googlesource.com/chromium/src/+/9740cdd6e97675f0174592f75838...
(see patchsets like
https://bugs.webkit.org/attachment.cgi?id=103144&action=prettypatch, for
example).

So that's why I opted not to fold this line in.

+        // block }.
         inlineStyle->forceInline();
         // FIXME: Should this be included in forceInline?
         inlineStyle->style()->setProperty(CSSPropertyFloat, CSSValueNone);
       }
       m_accumulator->appendTextWithInlineStyle(text, inlineStyle);
       break;
     }
     case Node::kElementNode: {
       Element& element = toElement(node);
       if ((element.isHTMLElement() && shouldAnnotate()) ||
@@ skipping 45 matching lines @@
   if (element.isHTMLElement() && shouldAnnotate())
     inlineStyle->mergeStyleFromRulesForSerialization(&toHTMLElement(element));
 
   return inlineStyle;
 }
 
 template class StyledMarkupSerializer<EditingStrategy>;
 template class StyledMarkupSerializer<EditingInFlatTreeStrategy>;
 
 }  // namespace blink