Rework float value/percentage scanning for VTTRegion

Source/core/html/track/vtt/VTTScanner.cpp

 /*
  * Copyright (c) 2013, Opera Software ASA. 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
@@ skipping 121 matching lines @@
     // hence that's what got passed to charactersToInt()), the remaining
     // failure mode for charactersToInt() is overflow, so if |validNumber| is
     // not true, then set |number| to the maximum int value.
     if (!validNumber)
         number = std::numeric_limits<int>::max();
     // Consume the digits.
     seekTo(runOfDigits.end());
     return numDigits;
 }
 
+bool VTTScanner::scanFloat(float& number)
+{
+    Run integerRun = collectWhile<isASCIIDigit>();
+    seekTo(integerRun.end());
+    Run decimalRun(position(), position(), m_is8Bit);
+    if (scan('.')) {
+        decimalRun = collectWhile<isASCIIDigit>();
+        seekTo(decimalRun.end());
+    }
+
+    // At least one digit required.
+    if (integerRun.isEmpty() && decimalRun.isEmpty()) {
+        // Restore to starting position.
+        seekTo(integerRun.start());
+        return false;

[Mike West, 2014/01/21 07:59:24]

Here you return false without setting `number`. At the bottom, you set invalid
numbers to float::max() and return true. Is that intentional?

[fs, 2014/01/21 08:19:57]

Intentional, yes. At this point, we have not managed to scan a valid float, so
we leave |number| as is and return false to signal failure (and don't consume
input).

Below however, we've verified that the input is wellformed - charactersToFloat
does that too, but has a differing definition of wellformed. Hence we interpret
|validNumber| - or rather, it's negation - as meaning that the number was too
large. We still return true though because the input was wellformed and we did
consume it (and |number| is set to the "best approximation" of the value). (If
we needed to detect the overflow as well, then we'd probably return some other
value for !validNumber.)

+    }
+
+    size_t lengthOfFloat = Run(integerRun.start(), position(), m_is8Bit).length();
+    bool validNumber;
+    if (m_is8Bit)
+        number = charactersToFloat(integerRun.start(), lengthOfFloat, &validNumber);
+    else
+        number = charactersToFloat(reinterpret_cast<const UChar*>(integerRun.start()), lengthOfFloat, &validNumber);
+
+    if (!validNumber)
+        number = std::numeric_limits<float>::max();
+    return true;
 }
+
+}