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

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

 /*
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights
+ * reserved.
  * Copyright (C) 2009, 2010 Google 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
  *    documentation and/or other materials provided with the distribution.
@@ skipping 214 matching lines @@
         strippedURLString.replace('"', """);
       else
         quoteChar = '\'';
     }
     result.append(quoteChar);
     result.append(strippedURLString);
     result.append(quoteChar);
     return;
   }
 
-  // FIXME: This does not fully match other browsers. Firefox percent-escapes non-ASCII characters for innerHTML.
+  // FIXME: This does not fully match other browsers. Firefox percent-escapes
+  // non-ASCII characters for innerHTML.
   result.append(quoteChar);
   appendAttributeValue(result, resolvedURLString, false);
   result.append(quoteChar);
 }
 
 void MarkupFormatter::appendNamespace(StringBuilder& result,
                                       const AtomicString& prefix,
                                       const AtomicString& namespaceURI,
                                       Namespaces& namespaces) {
   if (namespaceURI.isEmpty())
@@ skipping 17 matching lines @@
 }
 
 void MarkupFormatter::appendText(StringBuilder& result, Text& text) {
   const String& str = text.data();
   appendCharactersReplacingEntities(result, str, 0, str.length(),
                                     entityMaskForText(text));
 }
 
 void MarkupFormatter::appendComment(StringBuilder& result,
                                     const String& comment) {
-  // FIXME: Comment content is not escaped, but XMLSerializer (and possibly other callers) should raise an exception if it includes "-->".
+  // FIXME: Comment content is not escaped, but XMLSerializer (and possibly
+  // other callers) should raise an exception if it includes "-->".
   result.append("<!--");
   result.append(comment);
   result.append("-->");
 }
 
 void MarkupFormatter::appendXMLDeclaration(StringBuilder& result,
                                            const Document& document) {
   if (!document.hasXMLDeclaration())
     return;
 
@@ skipping 35 matching lines @@
     result.append(" SYSTEM \"");
     result.append(n.systemId());
     result.append('"');
   }
   result.append('>');
 }
 
 void MarkupFormatter::appendProcessingInstruction(StringBuilder& result,
                                                   const String& target,
                                                   const String& data) {
-  // FIXME: PI data is not escaped, but XMLSerializer (and possibly other callers) this should raise an exception if it includes "?>".
+  // FIXME: PI data is not escaped, but XMLSerializer (and possibly other
+  // callers) this should raise an exception if it includes "?>".
   result.append("<?");
   result.append(target);
   result.append(' ');
   result.append(data);
   result.append("?>");
 }
 
 void MarkupFormatter::appendOpenTag(StringBuilder& result,
                                     const Element& element,
                                     Namespaces* namespaces) {
@@ skipping 29 matching lines @@
   bool documentIsHTML = serializeAsHTMLDocument(element);
 
   QualifiedName prefixedName = attribute.name();
   if (documentIsHTML && !attributeIsInSerializedNamespace(attribute)) {
     result.append(' ');
     result.append(attribute.name().localName());
   } else {
     if (attribute.namespaceURI() == XMLNSNames::xmlnsNamespaceURI) {
       if (!attribute.prefix() && attribute.localName() != xmlnsAtom)
         prefixedName.setPrefix(xmlnsAtom);
-      if (namespaces) {  // Account for the namespace attribute we're about to append.
+      // Account for the namespace attribute we're about to append.
+      if (namespaces) {
         const AtomicString& lookupKey =
             (!attribute.prefix()) ? emptyAtom : attribute.localName();
         namespaces->set(lookupKey, attribute.value());
       }
     } else if (attribute.namespaceURI() == XMLNames::xmlNamespaceURI) {
       if (!attribute.prefix())
         prefixedName.setPrefix(xmlAtom);
     } else {
       if (attribute.namespaceURI() == XLinkNames::xlinkNamespaceURI) {
         if (!attribute.prefix())
           prefixedName.setPrefix(xlinkAtom);
       }
 
       if (namespaces && shouldAddNamespaceAttribute(attribute, element)) {
         if (!prefixedName.prefix()) {
-          // This behavior is in process of being standardized. See crbug.com/248044 and https://www.w3.org/Bugs/Public/show_bug.cgi?id=24208
+          // This behavior is in process of being standardized. See
+          // crbug.com/248044 and
+          // https://www.w3.org/Bugs/Public/show_bug.cgi?id=24208
           String prefixPrefix("ns", 2);
           for (unsigned i = attribute.namespaceURI().impl()->existingHash();;
                ++i) {
             AtomicString newPrefix(String(prefixPrefix + String::number(i)));
             AtomicString foundURI = namespaces->get(newPrefix);
             if (foundURI == attribute.namespaceURI() || foundURI == nullAtom) {
               // We already generated a prefix for this namespace.
               prefixedName.setPrefix(newPrefix);
               break;
             }
@@ skipping 14 matching lines @@
     appendQuotedURLAttributeValue(result, element, attribute);
   } else {
     result.append('"');
     appendAttributeValue(result, attribute.value(), documentIsHTML);
     result.append('"');
   }
 }
 
 void MarkupFormatter::appendCDATASection(StringBuilder& result,
                                          const String& section) {
-  // FIXME: CDATA content is not escaped, but XMLSerializer (and possibly other callers) should raise an exception if it includes "]]>".
+  // FIXME: CDATA content is not escaped, but XMLSerializer (and possibly other
+  // callers) should raise an exception if it includes "]]>".
   result.append("<![CDATA[");
   result.append(section);
   result.append("]]>");
 }
 
 bool MarkupFormatter::shouldAddNamespaceElement(const Element& element,
                                                 Namespaces& namespaces) const {
   // Don't add namespace attribute if it is already defined for this elem.
   const AtomicString& prefix = element.prefix();
   if (prefix.isEmpty()) {
     if (element.hasAttribute(xmlnsAtom)) {
       namespaces.set(emptyAtom, element.namespaceURI());
       return false;
     }
     return true;
   }
 
   return !element.hasAttribute(WTF::xmlnsWithColon + prefix);
 }
 
 bool MarkupFormatter::shouldAddNamespaceAttribute(
     const Attribute& attribute,
     const Element& element) const {
-  // xmlns and xmlns:prefix attributes should be handled by another branch in appendAttribute.
+  // xmlns and xmlns:prefix attributes should be handled by another branch in
+  // appendAttribute.
   DCHECK_NE(attribute.namespaceURI(), XMLNSNames::xmlnsNamespaceURI);
 
   // Attributes are in the null namespace by default.
   if (!attribute.namespaceURI())
     return false;
 
-  // Attributes without a prefix will need one generated for them, and an xmlns attribute for that prefix.
+  // Attributes without a prefix will need one generated for them, and an xmlns
+  // attribute for that prefix.
   if (!attribute.prefix())
     return true;
 
   return !element.hasAttribute(WTF::xmlnsWithColon + attribute.prefix());
 }
 
 EntityMask MarkupFormatter::entityMaskForText(const Text& text) const {
   if (!serializeAsHTMLDocument(text))
     return EntityMaskInPCDATA;
 
   // TODO(hajimehoshi): We need to switch EditingStrategy.
   const QualifiedName* parentName = nullptr;
   if (text.parentElement())
     parentName = &(text.parentElement())->tagQName();
 
   if (parentName && (*parentName == scriptTag || *parentName == styleTag ||
                      *parentName == xmpTag))
     return EntityMaskInCDATA;
   return EntityMaskInHTMLPCDATA;
 }
 
 // Rules of self-closure
 // 1. No elements in HTML documents use the self-closing syntax.
 // 2. Elements w/ children never self-close because they use a separate end tag.
-// 3. HTML elements which do not have a "forbidden" end tag will close with a separate end tag.
+// 3. HTML elements which do not have a "forbidden" end tag will close with a
+// separate end tag.
 // 4. Other elements self-close.
 bool MarkupFormatter::shouldSelfClose(const Element& element) const {
   if (serializeAsHTMLDocument(element))
     return false;
   if (element.hasChildren())
     return false;
   if (element.isHTMLElement() && !elementCannotHaveEndTag(element))
     return false;
   return true;
 }
 
 bool MarkupFormatter::serializeAsHTMLDocument(const Node& node) const {
   if (m_serializationType == SerializationType::ForcedXML)
     return false;
   return node.document().isHTMLDocument();
 }
 
 }  // namespace blink