Derive the step base for an input element as (now) specified.

Source/core/html/forms/RangeInputType.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2011 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 106 matching lines @@
 
 bool RangeInputType::supportsRequired() const
 {
     return false;
 }
 
 StepRange RangeInputType::createStepRange(AnyStepHandling anyStepHandling) const
 {
     DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (rangeDefaultStep, rangeDefaultStepBase, rangeStepScaleFactor));
 
-    const Decimal minimum = parseToNumber(element().fastGetAttribute(minAttr), rangeDefaultMinimum);
-    const Decimal maximum = ensureMaximum(parseToNumber(element().fastGetAttribute(maxAttr), rangeDefaultMaximum), minimum, rangeDefaultMaximum);
+    const Decimal minimum = parseToNumber(element().fastGetAttribute(minAttr), String(), rangeDefaultMinimum);
+    const Decimal maximum = ensureMaximum(parseToNumber(element().fastGetAttribute(maxAttr), String(), rangeDefaultMaximum), minimum, rangeDefaultMaximum);
 
     const AtomicString& precisionValue = element().fastGetAttribute(precisionAttr);
     if (!precisionValue.isNull()) {
         const Decimal step = equalIgnoringCase(precisionValue, "float") ? Decimal::nan() : 1;

[yosin_UTC9, 2013/11/25 01:26:41]

BTW, Can we stop supporting precsion="float"? If so, implementations of
InputType::createStepRange() are identical.

[tkent, 2013/11/25 01:36:33]

We have UseCounter for precision attribute.  We can make a decision of the
removal after M32 stable release.

         return StepRange(minimum, minimum, maximum, step, stepDescription);
     }
 
     const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element().fastGetAttribute(stepAttr));
     return StepRange(minimum, minimum, maximum, step, stepDescription);
 }
 
 bool RangeInputType::isSteppable() const
 {
     return true;
@@ skipping 109 matching lines @@
     RefPtr<HTMLElement> container = SliderContainerElement::create(document);
     container->appendChild(track.release());
     element().userAgentShadowRoot()->appendChild(container.release());
 }
 
 RenderObject* RangeInputType::createRenderer(RenderStyle*) const
 {
     return new RenderSlider(&element());
 }
 
-Decimal RangeInputType::parseToNumber(const String& src, const Decimal& defaultValue) const
+Decimal RangeInputType::parseToNumber(const String& src, const String& alternative, const Decimal& defaultValue) const
 {
+    if (!alternative.isEmpty()) {
+        Decimal result = parseToDecimalForNumberType(src, Decimal::nan());
+        if (!result.isFinite())
+            result = parseToDecimalForNumberType(alternative, defaultValue);
+
+        return result;
+    }
     return parseToDecimalForNumberType(src, defaultValue);
 }
 
 String RangeInputType::serialize(const Decimal& value) const
 {
     if (!value.isFinite())
         return String();
     return serializeForNumberType(value);
 }
 
@@ skipping 24 matching lines @@
 }
 
 String RangeInputType::fallbackValue() const
 {
     return serializeForNumberType(createStepRange(RejectAny).defaultValue());
 }
 
 String RangeInputType::sanitizeValue(const String& proposedValue) const
 {
     StepRange stepRange(createStepRange(RejectAny));
-    const Decimal proposedNumericValue = parseToNumber(proposedValue, stepRange.defaultValue());
+    const Decimal proposedNumericValue = parseToNumber(proposedValue, String(), stepRange.defaultValue());
     return serializeForNumberType(stepRange.clampValue(proposedNumericValue));
 }
 
 bool RangeInputType::shouldRespectListAttribute()
 {
     return InputType::themeSupportsDataListUI(this);
 }
 
 inline SliderThumbElement* RangeInputType::sliderThumbElement() const
 {
@@ skipping 28 matching lines @@
     if (!dataList)
         return;
     RefPtr<HTMLCollection> options = dataList->options();
     m_tickMarkValues.reserveCapacity(options->length());
     for (unsigned i = 0; i < options->length(); ++i) {
         Node* node = options->item(i);
         HTMLOptionElement* optionElement = toHTMLOptionElement(node);
         String optionValue = optionElement->value();
         if (!element().isValidValue(optionValue))
             continue;
-        m_tickMarkValues.append(parseToNumber(optionValue, Decimal::nan()));
+        m_tickMarkValues.append(parseToNumber(optionValue, String(), Decimal::nan()));
     }
     m_tickMarkValues.shrinkToFit();
     nonCopyingSort(m_tickMarkValues.begin(), m_tickMarkValues.end(), decimalCompare);
 }
 
 Decimal RangeInputType::findClosestTickMarkValue(const Decimal& value)
 {
     updateTickMarkValues();
     if (!m_tickMarkValues.size())
         return Decimal::nan();
@@ skipping 19 matching lines @@
             right = middle;
     }
     const Decimal closestLeft = middle ? m_tickMarkValues[middle - 1] : Decimal::infinity(Decimal::Negative);
     const Decimal closestRight = middle != m_tickMarkValues.size() ? m_tickMarkValues[middle] : Decimal::infinity(Decimal::Positive);
     if (closestRight - value < value - closestLeft)
         return closestRight;
     return closestLeft;
 }
 
 } // namespace WebCore