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

third_party/WebKit/Source/core/editing/serializers/Serialization.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 157 matching lines @@
     Node* constrainingAncestor) {
   Node* firstNode = startPosition.nodeAsRangeFirstNode();
   // For compatibility reason, we use container node of start and end
   // positions rather than first node and last node in selection.
   Node* commonAncestor =
       Strategy::commonAncestor(*startPosition.computeContainerNode(),
                                *endPosition.computeContainerNode());
   DCHECK(commonAncestor);
   HTMLElement* specialCommonAncestor = nullptr;
   if (shouldAnnotate == AnnotateForInterchange) {
-    // Include ancestors that aren't completely inside the range but are required to retain
-    // the structure and appearance of the copied markup.
+    // Include ancestors that aren't completely inside the range but are
+    // required to retain the structure and appearance of the copied markup.
     specialCommonAncestor =
         ancestorToRetainStructureAndAppearance(commonAncestor);
     if (Node* parentListNode = enclosingNodeOfType(
             firstPositionInOrBeforeNode(firstNode), isListItem)) {
       EphemeralRangeTemplate<Strategy> markupRange =
           EphemeralRangeTemplate<Strategy>(startPosition, endPosition);
       EphemeralRangeTemplate<Strategy> nodeRange = normalizeRange(
           EphemeralRangeTemplate<Strategy>::rangeOfContents(*parentListNode));
       if (nodeRange == markupRange) {
         ContainerNode* ancestor = parentListNode->parentNode();
@@ skipping 16 matching lines @@
   if (checkAncestor->layoutObject()) {
     HTMLElement* newSpecialCommonAncestor =
         toHTMLElement(highestEnclosingNodeOfType(
             Position::firstPositionInNode(checkAncestor),
             &isPresentationalHTMLElement, CanCrossEditingBoundary,
             constrainingAncestor));
     if (newSpecialCommonAncestor)
       specialCommonAncestor = newSpecialCommonAncestor;
   }
 
-  // If a single tab is selected, commonAncestor will be a text node inside a tab span.
-  // If two or more tabs are selected, commonAncestor will be the tab span.
-  // In either case, if there is a specialCommonAncestor already, it will necessarily be above
-  // any tab span that needs to be included.
+  // If a single tab is selected, commonAncestor will be a text node inside a
+  // tab span. If two or more tabs are selected, commonAncestor will be the tab
+  // span. In either case, if there is a specialCommonAncestor already, it will
+  // necessarily be above any tab span that needs to be included.
   if (!specialCommonAncestor && isTabHTMLSpanElementTextNode(commonAncestor))
     specialCommonAncestor =
         toHTMLSpanElement(Strategy::parent(*commonAncestor));
   if (!specialCommonAncestor && isTabHTMLSpanElement(commonAncestor))
     specialCommonAncestor = toHTMLSpanElement(commonAncestor);
 
   if (HTMLAnchorElement* enclosingAnchor =
           toHTMLAnchorElement(enclosingElementWithTag(
               Position::firstPositionInNode(specialCommonAncestor
                                                 ? specialCommonAncestor
                                                 : commonAncestor),
               aTag)))
     specialCommonAncestor = enclosingAnchor;
 
   return specialCommonAncestor;
 }
 
 template <typename Strategy>
 class CreateMarkupAlgorithm {
  public:
   static String createMarkup(
       const PositionTemplate<Strategy>& startPosition,
       const PositionTemplate<Strategy>& endPosition,
       EAnnotateForInterchange shouldAnnotate = DoNotAnnotateForInterchange,
       ConvertBlocksToInlines = ConvertBlocksToInlines::NotConvert,
       EAbsoluteURLs shouldResolveURLs = DoNotResolveURLs,
       Node* constrainingAncestor = nullptr);
 };
 
-// FIXME: Shouldn't we omit style info when annotate == DoNotAnnotateForInterchange?
-// FIXME: At least, annotation and style info should probably not be included in range.markupString()
+// FIXME: Shouldn't we omit style info when annotate ==
+// DoNotAnnotateForInterchange?
+// FIXME: At least, annotation and style info should probably not be included in
+// range.markupString()
 template <typename Strategy>
 String CreateMarkupAlgorithm<Strategy>::createMarkup(
     const PositionTemplate<Strategy>& startPosition,
     const PositionTemplate<Strategy>& endPosition,
     EAnnotateForInterchange shouldAnnotate,
     ConvertBlocksToInlines convertBlocksToInlines,
     EAbsoluteURLs shouldResolveURLs,
     Node* constrainingAncestor) {
   if (startPosition.isNull() || endPosition.isNull())
     return emptyString();
@@ skipping 40 matching lines @@
   return CreateMarkupAlgorithm<EditingInFlatTreeStrategy>::createMarkup(
       startPosition, endPosition, shouldAnnotate, convertBlocksToInlines,
       shouldResolveURLs, constrainingAncestor);
 }
 
 DocumentFragment* createFragmentFromMarkup(
     Document& document,
     const String& markup,
     const String& baseURL,
     ParserContentPolicy parserContentPolicy) {
-  // We use a fake body element here to trick the HTML parser to using the InBody insertion mode.
+  // We use a fake body element here to trick the HTML parser to using the
+  // InBody insertion mode.
   HTMLBodyElement* fakeBody = HTMLBodyElement::create(document);
   DocumentFragment* fragment = DocumentFragment::create(document);
 
   fragment->parseHTML(markup, fakeBody, parserContentPolicy);
 
   if (!baseURL.isEmpty() && baseURL != blankURL() &&
       baseURL != document.baseURL())
     completeURLs(*fragment, baseURL);
 
   return fragment;
@@ skipping 44 matching lines @@
   }
 }
 
 DocumentFragment* createFragmentFromMarkupWithContext(
     Document& document,
     const String& markup,
     unsigned fragmentStart,
     unsigned fragmentEnd,
     const String& baseURL,
     ParserContentPolicy parserContentPolicy) {
-  // FIXME: Need to handle the case where the markup already contains these markers.
+  // FIXME: Need to handle the case where the markup already contains these
+  // markers.
 
   StringBuilder taggedMarkup;
   taggedMarkup.append(markup.left(fragmentStart));
   MarkupFormatter::appendComment(taggedMarkup, fragmentMarkerTag);
   taggedMarkup.append(
       markup.substring(fragmentStart, fragmentEnd - fragmentStart));
   MarkupFormatter::appendComment(taggedMarkup, fragmentMarkerTag);
   taggedMarkup.append(markup.substring(fragmentEnd));
 
   DocumentFragment* taggedFragment = createFragmentFromMarkup(
@@ skipping 14 matching lines @@
 
   Range* range = Range::create(
       *taggedDocument,
       Position::afterNode(nodeBeforeContext).parentAnchoredEquivalent(),
       Position::beforeNode(nodeAfterContext).parentAnchoredEquivalent());
 
   Node* commonAncestor = range->commonAncestorContainer();
   HTMLElement* specialCommonAncestor =
       ancestorToRetainStructureAndAppearanceWithNoLayoutObject(commonAncestor);
 
-  // When there's a special common ancestor outside of the fragment, we must include it as well to
-  // preserve the structure and appearance of the fragment. For example, if the fragment contains
-  // TD, we need to include the enclosing TABLE tag as well.
+  // When there's a special common ancestor outside of the fragment, we must
+  // include it as well to preserve the structure and appearance of the
+  // fragment. For example, if the fragment contains TD, we need to include the
+  // enclosing TABLE tag as well.
   DocumentFragment* fragment = DocumentFragment::create(document);
   if (specialCommonAncestor)
     fragment->appendChild(specialCommonAncestor);
   else
     fragment->parserTakeAllChildrenFrom(toContainerNode(*commonAncestor));
 
   trimFragment(fragment, nodeBeforeContext, nodeAfterContext);
 
   return fragment;
 }
@@ skipping 103 matching lines @@
       shouldPreserveNewline(context)) {
     fragment->appendChild(document.createTextNode(string));
     if (string.endsWith('\n')) {
       HTMLBRElement* element = HTMLBRElement::create(document);
       element->setAttribute(classAttr, AppleInterchangeNewline);
       fragment->appendChild(element);
     }
     return fragment;
   }
 
-  // A string with no newlines gets added inline, rather than being put into a paragraph.
+  // A string with no newlines gets added inline, rather than being put into a
+  // paragraph.
   if (string.find('\n') == kNotFound) {
     fillContainerFromString(fragment, string);
     return fragment;
   }
 
   // Break string into paragraphs. Extra line breaks turn into empty paragraphs.
   Element* block =
       enclosingBlock(context.startPosition().nodeAsRangeFirstNode());
   bool useClonesOfEnclosingBlock =
       block && !isHTMLBodyElement(*block) && !isHTMLHtmlElement(*block) &&
@@ skipping 51 matching lines @@
   return fragment;
 }
 
 DocumentFragment* createFragmentForTransformToFragment(
     const String& sourceString,
     const String& sourceMIMEType,
     Document& outputDoc) {
   DocumentFragment* fragment = outputDoc.createDocumentFragment();
 
   if (sourceMIMEType == "text/html") {
-    // As far as I can tell, there isn't a spec for how transformToFragment is supposed to work.
-    // Based on the documentation I can find, it looks like we want to start parsing the fragment in the InBody insertion mode.
-    // Unfortunately, that's an implementation detail of the parser.
-    // We achieve that effect here by passing in a fake body element as context for the fragment.
+    // As far as I can tell, there isn't a spec for how transformToFragment is
+    // supposed to work. Based on the documentation I can find, it looks like we
+    // want to start parsing the fragment in the InBody insertion mode.
+    // Unfortunately, that's an implementation detail of the parser. We achieve
+    // that effect here by passing in a fake body element as context for the
+    // fragment.
     HTMLBodyElement* fakeBody = HTMLBodyElement::create(outputDoc);
     fragment->parseHTML(sourceString, fakeBody);
   } else if (sourceMIMEType == "text/plain") {
     fragment->parserAppendChild(Text::create(outputDoc, sourceString));
   } else {
     bool successfulParse = fragment->parseXML(sourceString, 0);
     if (!successfulParse)
       return nullptr;
   }
 
@@ skipping 77 matching lines @@
     return;
   }
 
   // FIXME: This is wrong if containerNode->firstChild() has more than one ref!
   if (containerNode->hasOneTextChild() && fragment->hasOneTextChild()) {
     toText(containerNode->firstChild())
         ->setData(toText(fragment->firstChild())->data());
     return;
   }
 
-  // FIXME: No need to replace the child it is a text node and its contents are already == text.
+  // FIXME: No need to replace the child it is a text node and its contents are
+  // already == text.
   if (containerNode->hasOneChild()) {
     containerNode->replaceChild(fragment, containerNode->firstChild(),
                                 exceptionState);
     return;
   }
 
   containerNode->removeChildren();
   containerNode->appendChild(fragment, exceptionState);
 }
 
 void replaceChildrenWithText(ContainerNode* container,
                              const String& text,
                              ExceptionState& exceptionState) {
   DCHECK(container);
   ContainerNode* containerNode(container);
 
   ChildListMutationScope mutation(*containerNode);
 
-  // FIXME: This is wrong if containerNode->firstChild() has more than one ref! Example:
+  // FIXME: This is wrong if containerNode->firstChild() has more than one ref!
+  // Example:
   // <div>foo</div>
   // <script>
   // var oldText = div.firstChild;
   // console.log(oldText.data); // foo
   // div.innerText = "bar";
   // console.log(oldText.data); // bar!?!
   // </script>
   // I believe this is an intentional benchmark cheat from years ago.
   // We should re-visit if we actually want this still.
   if (containerNode->hasOneTextChild()) {
     toText(containerNode->firstChild())->setData(text);
     return;
   }
 
-  // NOTE: This method currently always creates a text node, even if that text node will be empty.
+  // NOTE: This method currently always creates a text node, even if that text
+  // node will be empty.
   Text* textNode = Text::create(containerNode->document(), text);
 
-  // FIXME: No need to replace the child it is a text node and its contents are already == text.
+  // FIXME: No need to replace the child it is a text node and its contents are
+  // already == text.
   if (containerNode->hasOneChild()) {
     containerNode->replaceChild(textNode, containerNode->firstChild(),
                                 exceptionState);
     return;
   }
 
   containerNode->removeChildren();
   containerNode->appendChild(textNode, exceptionState);
 }
 
 void mergeWithNextTextNode(Text* textNode, ExceptionState& exceptionState) {
   DCHECK(textNode);
   Node* next = textNode->nextSibling();
   if (!next || !next->isTextNode())
     return;
 
   Text* textNext = toText(next);
   textNode->appendData(textNext->data());
   if (textNext->parentNode())  // Might have been removed by mutation event.
     textNext->remove(exceptionState);
 }
 
 template class CORE_TEMPLATE_EXPORT CreateMarkupAlgorithm<EditingStrategy>;
 template class CORE_TEMPLATE_EXPORT
     CreateMarkupAlgorithm<EditingInFlatTreeStrategy>;
 
 }  // namespace blink