Reformat comments in core/html/parser

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

 /*
  * Copyright (C) 2010 Apple 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.
  *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
- * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/html/parser/HTMLParserIdioms.h"
 
 #include "core/HTMLNames.h"
 #include "wtf/MathExtras.h"
 #include "wtf/text/AtomicString.h"
 #include "wtf/text/ParsingUtilities.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringHash.h"
@@ skipping 58 matching lines @@
 }
 
 String serializeForNumberType(double number) {
   // According to HTML5, "the best representation of the number n as a floating
   // point number" is a string produced by applying ToString() to n.
   return String::numberToStringECMAScript(number);
 }
 
 Decimal parseToDecimalForNumberType(const String& string,
                                     const Decimal& fallbackValue) {
-  // http://www.whatwg.org/specs/web-apps/current-work/#floating-point-numbers and parseToDoubleForNumberType
-  // String::toDouble() accepts leading + and whitespace characters, which are not valid here.
+  // http://www.whatwg.org/specs/web-apps/current-work/#floating-point-numbers
+  // and parseToDoubleForNumberType String::toDouble() accepts leading + and
+  // whitespace characters, which are not valid here.
   const UChar firstCharacter = string[0];
   if (firstCharacter != '-' && firstCharacter != '.' &&
       !isASCIIDigit(firstCharacter))
     return fallbackValue;
 
   const Decimal value = Decimal::fromString(string);
   if (!value.isFinite())
     return fallbackValue;
 
-  // Numbers are considered finite IEEE 754 Double-precision floating point values.
+  // Numbers are considered finite IEEE 754 Double-precision floating point
+  // values.
   const Decimal doubleMax =
       Decimal::fromDouble(std::numeric_limits<double>::max());
   if (value < -doubleMax || value > doubleMax)
     return fallbackValue;
 
   // We return +0 for -0 case.
   return value.isZero() ? Decimal(0) : value;
 }
 
 static double checkDoubleValue(double value, bool valid, double fallbackValue) {
   if (!valid)
     return fallbackValue;
 
-  // NaN and infinity are considered valid by String::toDouble, but not valid here.
+  // NaN and infinity are considered valid by String::toDouble, but not valid
+  // here.
   if (!std::isfinite(value))
     return fallbackValue;
 
-  // Numbers are considered finite IEEE 754 Double-precision floating point values.
+  // Numbers are considered finite IEEE 754 Double-precision floating point
+  // values.
   if (-std::numeric_limits<double>::max() > value ||
       value > std::numeric_limits<double>::max())
     return fallbackValue;
 
   // The following expression converts -0 to +0.
   return value ? value : 0;
 }
 
 double parseToDoubleForNumberType(const String& string, double fallbackValue) {
   // http://www.whatwg.org/specs/web-apps/current-work/#floating-point-numbers
-  // String::toDouble() accepts leading + and whitespace characters, which are not valid here.
+  // String::toDouble() accepts leading + and whitespace characters, which are
+  // not valid here.
   UChar firstCharacter = string[0];
   if (firstCharacter != '-' && firstCharacter != '.' &&
       !isASCIIDigit(firstCharacter))
     return fallbackValue;
   if (string.endsWith('.'))
     return fallbackValue;
 
   bool valid = false;
   double value = string.toDouble(&valid);
   return checkDoubleValue(value, valid, fallbackValue);
@@ skipping 67 matching lines @@
 
 template <typename CharacterType>
 static bool parseHTMLNonNegativeIntegerInternal(const CharacterType* position,
                                                 const CharacterType* end,
                                                 unsigned& value) {
   // This function is an implementation of the following algorithm:
   // https://html.spec.whatwg.org/multipage/infrastructure.html#rules-for-parsing-non-negative-integers
   // However, in order to support integers >= 2^31, we fold [1] into this.
   // 'Step N' in the following comments refers to [1].
   //
-  // [1] https://html.spec.whatwg.org/multipage/infrastructure.html#rules-for-parsing-integers
+  // [1]
+  // https://html.spec.whatwg.org/multipage/infrastructure.html#rules-for-parsing-integers
 
   // Step 3: Let sign have the value "positive".
   int sign = 1;
 
   // Step 4: Skip whitespace.
   while (position < end) {
     if (!isHTMLSpace<CharacterType>(*position))
       break;
     ++position;
   }
@@ skipping 211 matching lines @@
   if (length > StringImpl::highestStaticStringLength())
     return nullptr;
   // computeHashAndMaskTop8Bits is the function StringImpl::hash() uses.
   unsigned hash = StringHasher::computeHashAndMaskTop8Bits(characters, length);
   const WTF::StaticStringsTable& table = StringImpl::allStaticStrings();
   ASSERT(!table.isEmpty());
 
   WTF::StaticStringsTable::const_iterator it = table.find(hash);
   if (it == table.end())
     return nullptr;
-  // It's possible to have hash collisions between arbitrary strings and
-  // known identifiers (e.g. "bvvfg" collides with "script").
-  // However ASSERTs in StringImpl::createStatic guard against there ever being collisions
-  // between static strings.
+  // It's possible to have hash collisions between arbitrary strings and known
+  // identifiers (e.g. "bvvfg" collides with "script"). However ASSERTs in
+  // StringImpl::createStatic guard against there ever being collisions between
+  // static strings.
   if (!equal(it->value, characters, length))
     return nullptr;
   return it->value;
 }
 
 String attemptStaticStringCreation(const LChar* characters, size_t size) {
   String string(findStringIfStatic(characters, size));
   if (string.impl())
     return string;
   return String(characters, size);
 }
 
 String attemptStaticStringCreation(const UChar* characters,
                                    size_t size,
                                    CharacterWidth width) {
   String string(findStringIfStatic(characters, size));
   if (string.impl())
     return string;
   if (width == Likely8Bit)
     string = StringImpl::create8BitIfPossible(characters, size);
   else if (width == Force8Bit)
     string = String::make8BitFrom16BitSource(characters, size);
   else
     string = String(characters, size);
 
   return string;
 }
 
 }  // namespace blink