Rework the "rules for parsing dimension values" implementation

third_party/WebKit/Source/core/html/HTMLDimension.cpp

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 12 matching lines @@
  * 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/HTMLDimension.h"
 
+#include "core/html/parser/HTMLParserIdioms.h"
 #include "wtf/MathExtras.h"
+#include "wtf/text/ParsingUtilities.h"
 #include "wtf/text/StringToNumber.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 template <typename CharacterType>
 static HTMLDimension parseDimension(const CharacterType* characters,
                                     size_t lastParsedIndex,
                                     size_t endOfCurrentToken) {
   HTMLDimension::HTMLDimensionType type = HTMLDimension::Absolute;
@@ skipping 95 matching lines @@
     parsedDimensions.append(
         parseDimension(trimmedString, lastParsedIndex, nextComma));
     lastParsedIndex = nextComma + 1;
   }
 
   parsedDimensions.append(
       parseDimension(trimmedString, lastParsedIndex, trimmedString.length()));
   return parsedDimensions;
 }
 
+template <typename CharacterType>
+static bool parseDimensionValue(const CharacterType* current,
+                                const CharacterType* end,
+                                HTMLDimension& dimension) {
+  skipWhile<CharacterType, isHTMLSpace>(current, end);
+  // Deviation: HTML allows '+' here.
+  const CharacterType* numberStart = current;
+  if (!skipExactly<CharacterType, isASCIIDigit>(current, end))
+    return false;
+  skipWhile<CharacterType, isASCIIDigit>(current, end);
+  if (skipExactly<CharacterType>(current, end, '.')) {
+    // Deviation: HTML requires a digit after the full stop to be able to treat
+    // the value as a percentage (if not, the '.' will considered "garbage",
+    // yielding a regular length.) Gecko and Edge does not.
+    skipWhile<CharacterType, isASCIIDigit>(current, end);
+  }
+  bool ok;
+  double value = charactersToDouble(numberStart, current - numberStart, &ok);
+  if (!ok)
+    return false;
+  HTMLDimension::HTMLDimensionType type = HTMLDimension::Absolute;
+  if (current < end) {
+    if (*current == '%') {
+      type = HTMLDimension::Percentage;
+    } else if (*current == '*') {
+      // Deviation: HTML does not recognize '*' in this context, and we don't
+      // treat it as a valid value. We do count it though, so this is purely
+      // for statistics. Note though that per the specced behavior, "<number>*"
+      // would be the same as "<number>" (i.e '*' would just be trailing
+      // garbage.)
+      type = HTMLDimension::Relative;
+    }
+  }
+  dimension = HTMLDimension(value, type);
+  return true;
+}
+
+// https://html.spec.whatwg.org/multipage/infrastructure.html#rules-for-parsing-dimension-values
+bool parseDimensionValue(const String& input, HTMLDimension& dimension) {
+  if (input.isEmpty())
+    return false;
+  if (input.is8Bit()) {
+    return parseDimensionValue(input.characters8(),
+                               input.characters8() + input.length(), dimension);
+  }
+  return parseDimensionValue(input.characters16(),
+                             input.characters16() + input.length(), dimension);
+}
+
 }  // namespace blink