Reformat comments in core/html/parser

third_party/WebKit/Source/core/html/parser/TextResourceDecoder.cpp

 /*
     Copyright (C) 1999 Lars Knoll (knoll@mpi-hd.mpg.de)
-    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights reserved.
+    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All
+    rights reserved.
     Copyright (C) 2005, 2006, 2007 Alexey Proskuryakov (ap@nypop.com)
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ skipping 64 matching lines @@
                               char b4,
                               char b5,
                               char b6,
                               char b7,
                               char b8,
                               char b9) {
   return p[0] == b0 && p[1] == b1 && p[2] == b2 && p[3] == b3 && p[4] == b4 &&
          p[5] == b5 && p[6] == b6 && p[7] == b7 && p[8] == b8 && p[9] == b9;
 }
 
-// You might think we should put these find functions elsewhere, perhaps with the
-// similar functions that operate on UChar, but arguably only the decoder has
-// a reason to process strings of char rather than UChar.
+// You might think we should put these find functions elsewhere, perhaps with
+// the similar functions that operate on UChar, but arguably only the decoder
+// has a reason to process strings of char rather than UChar.
 
 static int find(const char* subject, size_t subjectLength, const char* target) {
   size_t targetLength = strlen(target);
   if (targetLength > subjectLength)
     return -1;
   for (size_t i = 0; i <= subjectLength - targetLength; ++i) {
     bool match = true;
     for (size_t j = 0; j < targetLength; ++j) {
       if (subject[i + j] != target[j]) {
         match = false;
@@ skipping 21 matching lines @@
   if (equalIgnoringCase(mimeType, "text/html"))
     return HTMLContent;
   if (DOMImplementation::isXMLMIMEType(mimeType))
     return XMLContent;
   return PlainTextContent;
 }
 
 const WTF::TextEncoding& TextResourceDecoder::defaultEncoding(
     ContentType contentType,
     const WTF::TextEncoding& specifiedDefaultEncoding) {
-  // Despite 8.5 "Text/xml with Omitted Charset" of RFC 3023, we assume UTF-8 instead of US-ASCII
-  // for text/xml. This matches Firefox.
+  // Despite 8.5 "Text/xml with Omitted Charset" of RFC 3023, we assume UTF-8
+  // instead of US-ASCII for text/xml. This matches Firefox.
   if (contentType == XMLContent)
     return UTF8Encoding();
   if (!specifiedDefaultEncoding.isValid())
     return Latin1Encoding();
   return specifiedDefaultEncoding;
 }
 
 TextResourceDecoder::TextResourceDecoder(
     const String& mimeType,
     const WTF::TextEncoding& specifiedDefaultEncoding,
@@ skipping 10 matching lines @@
       m_sawError(false),
       m_encodingDetectionOption(encodingDetectionOption) {
   if (m_encodingDetectionOption == AlwaysUseUTF8ForText)
     ASSERT(m_contentType == PlainTextContent && m_encoding == UTF8Encoding());
 }
 
 TextResourceDecoder::~TextResourceDecoder() {}
 
 void TextResourceDecoder::setEncoding(const WTF::TextEncoding& encoding,
                                       EncodingSource source) {
-  // In case the encoding didn't exist, we keep the old one (helps some sites specifying invalid encodings).
+  // In case the encoding didn't exist, we keep the old one (helps some sites
+  // specifying invalid encodings).
   if (!encoding.isValid())
     return;
 
-  // When encoding comes from meta tag (i.e. it cannot be XML files sent via XHR),
-  // treat x-user-defined as windows-1252 (bug 18270)
+  // When encoding comes from meta tag (i.e. it cannot be XML files sent via
+  // XHR), treat x-user-defined as windows-1252 (bug 18270)
   if (source == EncodingFromMetaTag &&
       !strcasecmp(encoding.name(), "x-user-defined"))
     m_encoding = "windows-1252";
   else if (source == EncodingFromMetaTag || source == EncodingFromXMLHeader ||
            source == EncodingFromCSSCharset)
     m_encoding = encoding.closestByteBasedEquivalent();
   else
     m_encoding = encoding;
 
   m_codec.reset();
@@ skipping 33 matching lines @@
   while (end < len && str[end] != quoteMark)
     ++end;
   if (end >= len)
     return -1;
 
   encodingLength = end - pos;
   return pos;
 }
 
 size_t TextResourceDecoder::checkForBOM(const char* data, size_t len) {
-  // Check for UTF-16/32 or UTF-8 BOM mark at the beginning, which is a sure sign of a Unicode encoding.
-  // We let it override even a user-chosen encoding.
+  // Check for UTF-16/32 or UTF-8 BOM mark at the beginning, which is a sure
+  // sign of a Unicode encoding. We let it override even a user-chosen encoding.
   ASSERT(!m_checkedForBOM);
 
   size_t lengthOfBOM = 0;
 
   size_t bufferLength = m_buffer.size();
 
   size_t buf1Len = bufferLength;
   size_t buf2Len = len;
   const unsigned char* buf1 =
       reinterpret_cast<const unsigned char*>(m_buffer.data());
@@ skipping 95 matching lines @@
 
   movedDataToBuffer = true;
 
   const char* ptr = m_buffer.data();
   const char* pEnd = ptr + m_buffer.size();
 
   // Is there enough data available to check for XML declaration?
   if (m_buffer.size() < minimumLengthOfXMLDeclaration)
     return false;
 
-  // Handle XML declaration, which can have encoding in it. This encoding is honored even for HTML documents.
-  // It is an error for an XML declaration not to be at the start of an XML document, and it is ignored in HTML documents in such case.
+  // Handle XML declaration, which can have encoding in it. This encoding is
+  // honored even for HTML documents. It is an error for an XML declaration not
+  // to be at the start of an XML document, and it is ignored in HTML documents
+  // in such case.
   if (bytesEqual(ptr, '<', '?', 'x', 'm', 'l')) {
     const char* xmlDeclarationEnd = ptr;
     while (xmlDeclarationEnd != pEnd && *xmlDeclarationEnd != '>')
       ++xmlDeclarationEnd;
     if (xmlDeclarationEnd == pEnd)
       return false;
-    // No need for +1, because we have an extra "?" to lose at the end of XML declaration.
+    // No need for +1, because we have an extra "?" to lose at the end of XML
+    // declaration.
     int len = 0;
     int pos = findXMLEncoding(ptr, xmlDeclarationEnd - ptr, len);
     if (pos != -1)
       setEncoding(findTextEncoding(ptr + pos, len), EncodingFromXMLHeader);
-    // continue looking for a charset - it may be specified in an HTTP-Equiv meta
+    // continue looking for a charset - it may be specified in an HTTP-Equiv
+    // meta
   } else if (bytesEqual(ptr, '<', 0, '?', 0, 'x', 0)) {
     setEncoding(UTF16LittleEndianEncoding(), AutoDetectedEncoding);
   } else if (bytesEqual(ptr, 0, '<', 0, '?', 0, 'x')) {
     setEncoding(UTF16BigEndianEncoding(), AutoDetectedEncoding);
   } else if (bytesEqual(ptr, '<', 0, 0, 0, '?', 0, 0, 0)) {
     setEncoding(UTF32LittleEndianEncoding(), AutoDetectedEncoding);
   } else if (bytesEqual(ptr, 0, 0, 0, '<', 0, 0, 0, '?')) {
     setEncoding(UTF32BigEndianEncoding(), AutoDetectedEncoding);
   }
 
@@ skipping 50 matching lines @@
   }
   DCHECK_LE(lengthOfBOM, m_buffer.size() + len);
 
   bool movedDataToBuffer = false;
 
   if (m_contentType == CSSContent && !m_checkedForCSSCharset) {
     if (!checkForCSSCharset(data, len, movedDataToBuffer))
       return emptyString();
   }
 
-  // We check XML declaration in HTML content only if there is enough data available
+  // We check XML declaration in HTML content only if there is enough data
+  // available
   if (((m_contentType == HTMLContent && len >= minimumLengthOfXMLDeclaration) ||
        m_contentType == XMLContent) &&
       !m_checkedForXMLCharset) {
     if (!checkForXMLCharset(data, len, movedDataToBuffer))
       return emptyString();
   }
 
   const char* dataForDecode = data + lengthOfBOM;
   size_t lengthForDecode = len - lengthOfBOM;
 
@@ skipping 50 matching lines @@
   String result = m_codec->decode(
       m_buffer.data(), m_buffer.size(), FetchEOF,
       m_contentType == XMLContent && !m_useLenientXMLDecoding, m_sawError);
   m_buffer.clear();
   m_codec.reset();
   m_checkedForBOM = false;  // Skip BOM again when re-decoding.
   return result;
 }
 
 }  // namespace blink