Changeset 120313 in webkit


Ignore:
Timestamp:
Jun 14, 2012 4:53:43 AM (12 years ago)
Author:
yosin@chromium.org
Message:

[Form] Replace InputNumber type to Decimal type and drop InputNumber
​https://bugs.webkit.org/show_bug.cgi?id=88746

Reviewed by Kent Tamura.

This patch removes InputNumber introduced by r119540 by replacing
InputNumber type to Decimal type and changing convertDoubleToDecimal
and convertDecimalToDouble to Decimal::fromDouble and
Decimal::toDouble, respectively.

No new tests. This patch doesn't change behavior.

  • html/BaseDateAndTimeInputType.cpp:

(WebCore::BaseDateAndTimeInputType::setValueAsDecimal):
(WebCore::BaseDateAndTimeInputType::defaultValueForStepUp):
(WebCore::BaseDateAndTimeInputType::parseToNumber):
(WebCore::BaseDateAndTimeInputType::serialize):
(WebCore::BaseDateAndTimeInputType::serializeWithComponents):
(WebCore::BaseDateAndTimeInputType::serializeWithMilliseconds):

  • html/BaseDateAndTimeInputType.h:

(BaseDateAndTimeInputType):

  • html/DateInputType.cpp:

(WebCore::DateInputType::createStepRange):

  • html/DateTimeInputType.cpp:

(WebCore::DateTimeInputType::defaultValueForStepUp):
(WebCore::DateTimeInputType::createStepRange):

  • html/DateTimeInputType.h:

(DateTimeInputType):

  • html/DateTimeLocalInputType.cpp:

(WebCore::DateTimeLocalInputType::createStepRange):

  • html/HTMLInputElement.cpp:

(WebCore::HTMLInputElement::getAllowedValueStep):

  • html/HTMLInputElement.h:

(HTMLInputElement):

  • html/InputType.cpp:

(WebCore::InputType::setValueAsDouble):
(WebCore::InputType::setValueAsDecimal):
(WebCore::InputType::rangeUnderflow):
(WebCore::InputType::rangeOverflow):
(WebCore::InputType::defaultValueForStepUp):
(WebCore::InputType::minimum):
(WebCore::InputType::maximum):
(WebCore::InputType::isInRange):
(WebCore::InputType::isOutOfRange):
(WebCore::InputType::stepMismatch):
(WebCore::InputType::validationMessage):
(WebCore::InputType::parseToNumber):
(WebCore::InputType::parseToNumberOrNaN):
(WebCore::InputType::serialize):
(WebCore::InputType::applyStep):
(WebCore::InputType::getAllowedValueStep):
(WebCore::InputType::stepUpFromRenderer):

  • html/InputType.h:

(InputType):

  • html/MonthInputType.cpp:

(WebCore::MonthInputType::defaultValueForStepUp):
(WebCore::MonthInputType::createStepRange):
(WebCore::MonthInputType::parseToNumber):

  • html/MonthInputType.h:

(MonthInputType):

  • html/NumberInputType.cpp:

(WebCore::NumberInputType::setValueAsDecimal):
(WebCore::NumberInputType::createStepRange):
(WebCore::NumberInputType::parseToNumber):
(WebCore::NumberInputType::serialize):

  • html/NumberInputType.h:

(NumberInputType):

  • html/RangeInputType.cpp:

(WebCore::ensureMaximum):
(WebCore::RangeInputType::setValueAsDecimal):
(WebCore::RangeInputType::createStepRange):
(WebCore::RangeInputType::handleKeydownEvent):
(WebCore::RangeInputType::parseToNumber):
(WebCore::RangeInputType::serialize):
(WebCore::RangeInputType::sanitizeValue):

  • html/RangeInputType.h:

(RangeInputType):

  • html/StepRange.cpp:

(WebCore::StepRange::StepRange):
(WebCore::StepRange::acceptableError):
(WebCore::StepRange::alignValueForStep):
(WebCore::StepRange::clampValue):
(WebCore::StepRange::parseStep):
(WebCore::StepRange::roundByStep):
(WebCore::StepRange::stepMismatch):

  • html/StepRange.h:

(WebCore::StepRange::StepDescription::defaultValue):
(StepRange):
(WebCore::StepRange::maximum):
(WebCore::StepRange::minimum):
(WebCore::StepRange::step):
(WebCore::StepRange::stepBase):
(WebCore::StepRange::defaultValue):
(WebCore::StepRange::proportionFromValue):
(WebCore::StepRange::valueFromProportion):

  • html/TimeInputType.cpp:

(WebCore::TimeInputType::defaultValueForStepUp):
(WebCore::TimeInputType::createStepRange):

  • html/TimeInputType.h:

(TimeInputType):

  • html/WeekInputType.cpp:

(WebCore::WeekInputType::createStepRange):

  • html/shadow/CalendarPickerElement.cpp:

(WebCore::CalendarPickerElement::writeDocument):

  • html/shadow/SliderThumbElement.cpp:

(WebCore::sliderPosition):
(WebCore::RenderSliderThumb::layout):
(WebCore::SliderThumbElement::setPositionFromPoint):

Location:
trunk/Source/WebCore
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r120311 r120313  
     12012-06-14  Yoshifumi Inoue  <yosin@chromium.org>
     2
     3        [Form] Replace InputNumber type to Decimal type and drop InputNumber
     4        https://bugs.webkit.org/show_bug.cgi?id=88746
     5
     6        Reviewed by Kent Tamura.
     7
     8        This patch removes InputNumber introduced by r119540 by replacing
     9        InputNumber type to Decimal type and changing convertDoubleToDecimal
     10        and convertDecimalToDouble to Decimal::fromDouble and
     11        Decimal::toDouble, respectively.
     12
     13        No new tests. This patch doesn't change behavior.
     14
     15        * html/BaseDateAndTimeInputType.cpp:
     16        (WebCore::BaseDateAndTimeInputType::setValueAsDecimal):
     17        (WebCore::BaseDateAndTimeInputType::defaultValueForStepUp):
     18        (WebCore::BaseDateAndTimeInputType::parseToNumber):
     19        (WebCore::BaseDateAndTimeInputType::serialize):
     20        (WebCore::BaseDateAndTimeInputType::serializeWithComponents):
     21        (WebCore::BaseDateAndTimeInputType::serializeWithMilliseconds):
     22        * html/BaseDateAndTimeInputType.h:
     23        (BaseDateAndTimeInputType):
     24        * html/DateInputType.cpp:
     25        (WebCore::DateInputType::createStepRange):
     26        * html/DateTimeInputType.cpp:
     27        (WebCore::DateTimeInputType::defaultValueForStepUp):
     28        (WebCore::DateTimeInputType::createStepRange):
     29        * html/DateTimeInputType.h:
     30        (DateTimeInputType):
     31        * html/DateTimeLocalInputType.cpp:
     32        (WebCore::DateTimeLocalInputType::createStepRange):
     33        * html/HTMLInputElement.cpp:
     34        (WebCore::HTMLInputElement::getAllowedValueStep):
     35        * html/HTMLInputElement.h:
     36        (HTMLInputElement):
     37        * html/InputType.cpp:
     38        (WebCore::InputType::setValueAsDouble):
     39        (WebCore::InputType::setValueAsDecimal):
     40        (WebCore::InputType::rangeUnderflow):
     41        (WebCore::InputType::rangeOverflow):
     42        (WebCore::InputType::defaultValueForStepUp):
     43        (WebCore::InputType::minimum):
     44        (WebCore::InputType::maximum):
     45        (WebCore::InputType::isInRange):
     46        (WebCore::InputType::isOutOfRange):
     47        (WebCore::InputType::stepMismatch):
     48        (WebCore::InputType::validationMessage):
     49        (WebCore::InputType::parseToNumber):
     50        (WebCore::InputType::parseToNumberOrNaN):
     51        (WebCore::InputType::serialize):
     52        (WebCore::InputType::applyStep):
     53        (WebCore::InputType::getAllowedValueStep):
     54        (WebCore::InputType::stepUpFromRenderer):
     55        * html/InputType.h:
     56        (InputType):
     57        * html/MonthInputType.cpp:
     58        (WebCore::MonthInputType::defaultValueForStepUp):
     59        (WebCore::MonthInputType::createStepRange):
     60        (WebCore::MonthInputType::parseToNumber):
     61        * html/MonthInputType.h:
     62        (MonthInputType):
     63        * html/NumberInputType.cpp:
     64        (WebCore::NumberInputType::setValueAsDecimal):
     65        (WebCore::NumberInputType::createStepRange):
     66        (WebCore::NumberInputType::parseToNumber):
     67        (WebCore::NumberInputType::serialize):
     68        * html/NumberInputType.h:
     69        (NumberInputType):
     70        * html/RangeInputType.cpp:
     71        (WebCore::ensureMaximum):
     72        (WebCore::RangeInputType::setValueAsDecimal):
     73        (WebCore::RangeInputType::createStepRange):
     74        (WebCore::RangeInputType::handleKeydownEvent):
     75        (WebCore::RangeInputType::parseToNumber):
     76        (WebCore::RangeInputType::serialize):
     77        (WebCore::RangeInputType::sanitizeValue):
     78        * html/RangeInputType.h:
     79        (RangeInputType):
     80        * html/StepRange.cpp:
     81        (WebCore::StepRange::StepRange):
     82        (WebCore::StepRange::acceptableError):
     83        (WebCore::StepRange::alignValueForStep):
     84        (WebCore::StepRange::clampValue):
     85        (WebCore::StepRange::parseStep):
     86        (WebCore::StepRange::roundByStep):
     87        (WebCore::StepRange::stepMismatch):
     88        * html/StepRange.h:
     89        (WebCore::StepRange::StepDescription::defaultValue):
     90        (StepRange):
     91        (WebCore::StepRange::maximum):
     92        (WebCore::StepRange::minimum):
     93        (WebCore::StepRange::step):
     94        (WebCore::StepRange::stepBase):
     95        (WebCore::StepRange::defaultValue):
     96        (WebCore::StepRange::proportionFromValue):
     97        (WebCore::StepRange::valueFromProportion):
     98        * html/TimeInputType.cpp:
     99        (WebCore::TimeInputType::defaultValueForStepUp):
     100        (WebCore::TimeInputType::createStepRange):
     101        * html/TimeInputType.h:
     102        (TimeInputType):
     103        * html/WeekInputType.cpp:
     104        (WebCore::WeekInputType::createStepRange):
     105        * html/shadow/CalendarPickerElement.cpp:
     106        (WebCore::CalendarPickerElement::writeDocument):
     107        * html/shadow/SliderThumbElement.cpp:
     108        (WebCore::sliderPosition):
     109        (WebCore::RenderSliderThumb::layout):
     110        (WebCore::SliderThumbElement::setPositionFromPoint):
     111
    11122012-06-14  Jan Keromnes  <janx@linux.com>
    2113

  • trunk/Source/WebCore/html/BaseDateAndTimeInputType.cpp

    r119948 r120313  
    6666}
    6767
    68 void BaseDateAndTimeInputType::setValueAsInputNumber(const InputNumber& newValue, TextFieldEventBehavior eventBehavior, ExceptionCode&) const
     68void BaseDateAndTimeInputType::setValueAsDecimal(const Decimal& newValue, TextFieldEventBehavior eventBehavior, ExceptionCode&) const
    6969{
    7070    element()->setValue(serialize(newValue), eventBehavior);
    … …  
    8181}
    8282
    83 InputNumber BaseDateAndTimeInputType::defaultValueForStepUp() const
     83Decimal BaseDateAndTimeInputType::defaultValueForStepUp() const
    8484{
    8585    double ms = currentTimeMS();
    … …  
    8787    double dstOffset = calculateDSTOffset(ms, utcOffset);
    8888    int offset = static_cast<int>((utcOffset + dstOffset) / msPerMinute);
    89     return convertDoubleToInputNumber(ms + (offset * msPerMinute));
     89    return Decimal::fromDouble(ms + (offset * msPerMinute));
    9090}
    9191
    … …  
    119119}
    120120
    121 InputNumber BaseDateAndTimeInputType::parseToNumber(const String& source, const InputNumber& defaultValue) const
     121Decimal BaseDateAndTimeInputType::parseToNumber(const String& source, const Decimal& defaultValue) const
    122122{
    123123    const double doubleValue = parseToDouble(source);
    124     return isfinite(doubleValue) ? convertDoubleToInputNumber(doubleValue) : defaultValue;
     124    return isfinite(doubleValue) ? Decimal::fromDouble(doubleValue) : defaultValue;
    125125}
    126126
    … …  
    135135}
    136136
    137 String BaseDateAndTimeInputType::serialize(const InputNumber& value) const
     137String BaseDateAndTimeInputType::serialize(const Decimal& value) const
    138138{
    139139    if (!value.isFinite())
    140140        return String();
    141141    DateComponents date;
    142     if (!setMillisecondToDateComponents(convertInputNumberToDouble(value), &date))
     142    if (!setMillisecondToDateComponents(value.toDouble(), &date))
    143143        return String();
    144144    return serializeWithComponents(date);
    … …  
    147147String BaseDateAndTimeInputType::serializeWithComponents(const DateComponents& date) const
    148148{
    149     InputNumber step;
     149    Decimal step;
    150150    if (!element()->getAllowedValueStep(&step))
    151151        return date.toString();
    … …  
    159159String BaseDateAndTimeInputType::serializeWithMilliseconds(double value) const
    160160{
    161     return serialize(convertDoubleToInputNumber(value));
     161    return serialize(Decimal::fromDouble(value));
    162162}
    163163

  • trunk/Source/WebCore/html/BaseDateAndTimeInputType.h

    r119540 r120313  
    4343    BaseDateAndTimeInputType(HTMLInputElement* element) : TextFieldInputType(element) { }
    4444    virtual void handleKeydownEvent(KeyboardEvent*) OVERRIDE;
    45     virtual InputNumber parseToNumber(const String&, const InputNumber&) const OVERRIDE;
     45    virtual Decimal parseToNumber(const String&, const Decimal&) const OVERRIDE;
    4646    virtual bool parseToDateComponents(const String&, DateComponents*) const OVERRIDE;
    4747    String serializeWithComponents(const DateComponents&) const;
    … …  
    5454    virtual void setValueAsDate(double, ExceptionCode&) const OVERRIDE;
    5555    virtual double valueAsDouble() const OVERRIDE;
    56     virtual void setValueAsInputNumber(const InputNumber&, TextFieldEventBehavior, ExceptionCode&) const OVERRIDE;
     56    virtual void setValueAsDecimal(const Decimal&, TextFieldEventBehavior, ExceptionCode&) const OVERRIDE;
    5757    virtual bool typeMismatchFor(const String&) const OVERRIDE;
    5858    virtual bool typeMismatch() const OVERRIDE;
    59     virtual InputNumber defaultValueForStepUp() const OVERRIDE;
     59    virtual Decimal defaultValueForStepUp() const OVERRIDE;
    6060    virtual bool isSteppable() const OVERRIDE;
    6161    virtual void handleWheelEvent(WheelEvent*) OVERRIDE;
    62     virtual String serialize(const InputNumber&) const OVERRIDE;
     62    virtual String serialize(const Decimal&) const OVERRIDE;
    6363    virtual String serializeWithMilliseconds(double) const;
    6464    virtual String localizeValue(const String&) const OVERRIDE;

  • trunk/Source/WebCore/html/DateInputType.cpp

    r119948 r120313  
    7474    DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (dateDefaultStep, dateDefaultStepBase, dateStepScaleFactor, StepRange::ParsedStepValueShouldBeInteger));
    7575
    76     const InputNumber stepBase = parseToNumber(element()->fastGetAttribute(minAttr), 0);
    77     const InputNumber minimum = parseToNumber(element()->fastGetAttribute(minAttr), convertDoubleToInputNumber(DateComponents::minimumDate()));
    78     const InputNumber maximum = parseToNumber(element()->fastGetAttribute(maxAttr), convertDoubleToInputNumber(DateComponents::maximumDate()));
    79     const InputNumber step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
     76    const Decimal stepBase = parseToNumber(element()->fastGetAttribute(minAttr), 0);
     77    const Decimal minimum = parseToNumber(element()->fastGetAttribute(minAttr), Decimal::fromDouble(DateComponents::minimumDate()));
     78    const Decimal maximum = parseToNumber(element()->fastGetAttribute(maxAttr), Decimal::fromDouble(DateComponents::maximumDate()));
     79    const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
    8080    return StepRange(stepBase, minimum, maximum, step, stepDescription);
    8181}

  • trunk/Source/WebCore/html/DateTimeInputType.cpp

    r119948 r120313  
    6363}
    6464
    65 InputNumber DateTimeInputType::defaultValueForStepUp() const
     65Decimal DateTimeInputType::defaultValueForStepUp() const
    6666{
    67     return convertDoubleToInputNumber(currentTimeMS());
     67    return Decimal::fromDouble(currentTimeMS());
    6868}
    6969
    … …  
    7272    DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (dateTimeDefaultStep, dateTimeDefaultStepBase, dateTimeStepScaleFactor, StepRange::ScaledStepValueShouldBeInteger));
    7373
    74     const InputNumber stepBase = parseToNumber(element()->fastGetAttribute(minAttr), 0);
    75     const InputNumber minimum = parseToNumber(element()->fastGetAttribute(minAttr), convertDoubleToInputNumber(DateComponents::minimumDateTime()));
    76     const InputNumber maximum = parseToNumber(element()->fastGetAttribute(maxAttr), convertDoubleToInputNumber(DateComponents::maximumDateTime()));
    77     const InputNumber step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
     74    const Decimal stepBase = parseToNumber(element()->fastGetAttribute(minAttr), 0);
     75    const Decimal minimum = parseToNumber(element()->fastGetAttribute(minAttr), Decimal::fromDouble(DateComponents::minimumDateTime()));
     76    const Decimal maximum = parseToNumber(element()->fastGetAttribute(maxAttr), Decimal::fromDouble(DateComponents::maximumDateTime()));
     77    const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
    7878    return StepRange(stepBase, minimum, maximum, step, stepDescription);
    7979}

  • trunk/Source/WebCore/html/DateTimeInputType.h

    r119540 r120313  
    4747    virtual DateComponents::Type dateType() const OVERRIDE;
    4848    virtual StepRange createStepRange(AnyStepHandling) const OVERRIDE;
    49     virtual InputNumber defaultValueForStepUp() const OVERRIDE;
     49    virtual Decimal defaultValueForStepUp() const OVERRIDE;
    5050    virtual bool parseToDateComponentsInternal(const UChar*, unsigned length, DateComponents*) const OVERRIDE;
    5151    virtual bool setMillisecondToDateComponents(double, DateComponents*) const OVERRIDE;

  • trunk/Source/WebCore/html/DateTimeLocalInputType.cpp

    r119948 r120313  
    7878    DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (dateTimeLocalDefaultStep, dateTimeLocalDefaultStepBase, dateTimeLocalStepScaleFactor, StepRange::ScaledStepValueShouldBeInteger));
    7979
    80     const InputNumber stepBase = parseToNumber(element()->fastGetAttribute(minAttr), 0);
    81     const InputNumber minimum = parseToNumber(element()->fastGetAttribute(minAttr), convertDoubleToInputNumber(DateComponents::minimumDateTime()));
    82     const InputNumber maximum = parseToNumber(element()->fastGetAttribute(maxAttr), convertDoubleToInputNumber(DateComponents::maximumDateTime()));
    83     const InputNumber step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
     80    const Decimal stepBase = parseToNumber(element()->fastGetAttribute(minAttr), 0);
     81    const Decimal minimum = parseToNumber(element()->fastGetAttribute(minAttr), Decimal::fromDouble(DateComponents::minimumDateTime()));
     82    const Decimal maximum = parseToNumber(element()->fastGetAttribute(maxAttr), Decimal::fromDouble(DateComponents::maximumDateTime()));
     83    const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
    8484    return StepRange(stepBase, minimum, maximum, step, stepDescription);
    8585}

  • trunk/Source/WebCore/html/HTMLInputElement.cpp

    r120251 r120313  
    275275}
    276276
    277 bool HTMLInputElement::getAllowedValueStep(InputNumber* step) const
     277bool HTMLInputElement::getAllowedValueStep(Decimal* step) const
    278278{
    279279    return m_inputType->getAllowedValueStep(step);

  • trunk/Source/WebCore/html/HTMLInputElement.h

    r120081 r120313  
    6868    // Sets the "allowed value step" defined in the HTML spec to the specified double pointer.
    6969    // Returns false if there is no "allowed value step."
    70     bool getAllowedValueStep(InputNumber*) const;
     70    bool getAllowedValueStep(Decimal*) const;
    7171    StepRange createStepRange(AnyStepHandling) const;
    7272

  • trunk/Source/WebCore/html/InputType.cpp

    r120081 r120313  
    213213void InputType::setValueAsDouble(double doubleValue, TextFieldEventBehavior eventBehavior, ExceptionCode& ec) const
    214214{
    215     setValueAsInputNumber(convertDoubleToInputNumber(doubleValue), eventBehavior, ec);
    216 }
    217 
    218 void InputType::setValueAsInputNumber(const InputNumber&, TextFieldEventBehavior, ExceptionCode& ec) const
     215    setValueAsDecimal(Decimal::fromDouble(doubleValue), eventBehavior, ec);
     216}
     217
     218void InputType::setValueAsDecimal(const Decimal&, TextFieldEventBehavior, ExceptionCode& ec) const
    219219{
    220220    ec = INVALID_STATE_ERR;
    … …  
    257257        return false;
    258258
    259     const InputNumber numericValue = parseToNumberOrNaN(value);
     259    const Decimal numericValue = parseToNumberOrNaN(value);
    260260    if (!numericValue.isFinite())
    261261        return false;
    … …  
    269269        return false;
    270270
    271     const InputNumber numericValue = parseToNumberOrNaN(value);
     271    const Decimal numericValue = parseToNumberOrNaN(value);
    272272    if (!numericValue.isFinite())
    273273        return false;
    … …  
    276276}
    277277
    278 InputNumber InputType::defaultValueForStepUp() const
     278Decimal InputType::defaultValueForStepUp() const
    279279{
    280280    return 0;
    … …  
    283283double InputType::minimum() const
    284284{
    285     return convertInputNumberToDouble(createStepRange(RejectAny).minimum());
     285    return createStepRange(RejectAny).minimum().toDouble();
    286286}
    287287
    288288double InputType::maximum() const
    289289{
    290     return convertInputNumberToDouble(createStepRange(RejectAny).maximum());
     290    return createStepRange(RejectAny).maximum().toDouble();
    291291}
    292292
    … …  
    302302        return false;
    303303
    304     const InputNumber numericValue = parseToNumberOrNaN(value);
     304    const Decimal numericValue = parseToNumberOrNaN(value);
    305305    if (!numericValue.isFinite())
    306306        return true;
    … …  
    315315        return false;
    316316
    317     const InputNumber numericValue = parseToNumberOrNaN(value);
     317    const Decimal numericValue = parseToNumberOrNaN(value);
    318318    if (!numericValue.isFinite())
    319319        return true;
    … …  
    328328        return false;
    329329
    330     const InputNumber numericValue = parseToNumberOrNaN(value);
     330    const Decimal numericValue = parseToNumberOrNaN(value);
    331331    if (!numericValue.isFinite())
    332332        return false;
    … …  
    366366        return emptyString();
    367367
    368     const InputNumber numericValue = parseToNumberOrNaN(value);
     368    const Decimal numericValue = parseToNumberOrNaN(value);
    369369    if (!numericValue.isFinite())
    370370        return emptyString();
    … …  
    459459}
    460460
    461 InputNumber InputType::parseToNumber(const String&, const InputNumber& defaultValue) const
     461Decimal InputType::parseToNumber(const String&, const Decimal& defaultValue) const
    462462{
    463463    ASSERT_NOT_REACHED();
    … …  
    465465}
    466466
    467 InputNumber InputType::parseToNumberOrNaN(const String& string) const
     467Decimal InputType::parseToNumberOrNaN(const String& string) const
    468468{
    469469    return parseToNumber(string, Decimal::nan());
    … …  
    476476}
    477477
    478 String InputType::serialize(const InputNumber&) const
     478String InputType::serialize(const Decimal&) const
    479479{
    480480    ASSERT_NOT_REACHED();
    … …  
    881881    }
    882882
    883     const InputNumber current = parseToNumberOrNaN(element()->value());
     883    const Decimal current = parseToNumberOrNaN(element()->value());
    884884    if (!current.isFinite()) {
    885885        ec = INVALID_STATE_ERR;
    886886        return;
    887887    }
    888     InputNumber newValue = current + stepRange.step() * count;
     888    Decimal newValue = current + stepRange.step() * count;
    889889    if (!newValue.isFinite()) {
    890890        ec = INVALID_STATE_ERR;
    … …  
    892892    }
    893893
    894     const InputNumber acceptableErrorValue = stepRange.acceptableError();
     894    const Decimal acceptableErrorValue = stepRange.acceptableError();
    895895    if (newValue - stepRange.minimum() < -acceptableErrorValue) {
    896896        ec = INVALID_STATE_ERR;
    … …  
    911911        newValue = stepRange.maximum();
    912912
    913     setValueAsInputNumber(newValue, eventBehavior, ec);
     913    setValueAsDecimal(newValue, eventBehavior, ec);
    914914
    915915    if (AXObjectCache::accessibilityEnabled())
    … …  
    917917}
    918918
    919 bool InputType::getAllowedValueStep(InputNumber* step) const
     919bool InputType::getAllowedValueStep(Decimal* step) const
    920920{
    921921    StepRange stepRange(createStepRange(RejectAny));
    … …  
    990990      return;
    991991
    992     const InputNumber step = stepRange.step();
     992    const Decimal step = stepRange.step();
    993993
    994994    int sign;
    … …  
    10011001
    10021002    String currentStringValue = element()->value();
    1003     InputNumber current = parseToNumberOrNaN(currentStringValue);
     1003    Decimal current = parseToNumberOrNaN(currentStringValue);
    10041004    if (!current.isFinite()) {
    10051005        ExceptionCode ec;
    10061006        current = defaultValueForStepUp();
    1007         const InputNumber nextDiff = step * n;
     1007        const Decimal nextDiff = step * n;
    10081008        if (current < stepRange.minimum() - nextDiff)
    10091009            current = stepRange.minimum() - nextDiff;
    10101010        if (current > stepRange.maximum() - nextDiff)
    10111011            current = stepRange.maximum() - nextDiff;
    1012         setValueAsInputNumber(current, DispatchInputAndChangeEvent, ec);
     1012        setValueAsDecimal(current, DispatchInputAndChangeEvent, ec);
    10131013    }
    10141014    if ((sign > 0 && current < stepRange.minimum()) || (sign < 0 && current > stepRange.maximum())) {
    10151015        ExceptionCode ec;
    1016         setValueAsInputNumber(sign > 0 ? stepRange.minimum() : stepRange.maximum(), DispatchInputAndChangeEvent, ec);
     1016        setValueAsDecimal(sign > 0 ? stepRange.minimum() : stepRange.maximum(), DispatchInputAndChangeEvent, ec);
    10171017    } else {
    10181018        ExceptionCode ec;
    … …  
    10331033                newValue = stepRange.maximum();
    10341034
    1035             setValueAsInputNumber(newValue, n == 1 || n == -1 ? DispatchInputAndChangeEvent : DispatchNoEvent, ec);
     1035            setValueAsDecimal(newValue, n == 1 || n == -1 ? DispatchInputAndChangeEvent : DispatchNoEvent, ec);
    10361036            if (n > 1)
    10371037                applyStep(n - 1, AnyIsDefaultStep, DispatchInputAndChangeEvent, ec);

  • trunk/Source/WebCore/html/InputType.h

    r120081 r120313  
    141141    virtual double valueAsDouble() const;
    142142    virtual void setValueAsDouble(double, TextFieldEventBehavior, ExceptionCode&) const;
    143     virtual void setValueAsInputNumber(const InputNumber&, TextFieldEventBehavior, ExceptionCode&) const;
     143    virtual void setValueAsDecimal(const Decimal&, TextFieldEventBehavior, ExceptionCode&) const;
    144144
    145145    // Validation functions
    … …  
    158158    bool isInRange(const String&) const;
    159159    bool isOutOfRange(const String&) const;
    160     virtual InputNumber defaultValueForStepUp() const;
     160    virtual Decimal defaultValueForStepUp() const;
    161161    double minimum() const;
    162162    double maximum() const;
    163163    virtual bool sizeShouldIncludeDecoration(int defaultSize, int& preferredSize) const;
    164164    bool stepMismatch(const String&) const;
    165     virtual bool getAllowedValueStep(InputNumber*) const;
     165    virtual bool getAllowedValueStep(Decimal*) const;
    166166    virtual StepRange createStepRange(AnyStepHandling) const;
    167167    virtual void stepUp(int, ExceptionCode&);
    … …  
    264264
    265265    // Parses the specified string for the type, and return
    266     // the InputNumber value for the parsing result if the parsing
     266    // the Decimal value for the parsing result if the parsing
    267267    // succeeds; Returns defaultValue otherwise. This function can
    268268    // return NaN or Infinity only if defaultValue is NaN or Infinity.
    269     virtual InputNumber parseToNumber(const String&, const InputNumber& defaultValue) const;
     269    virtual Decimal parseToNumber(const String&, const Decimal& defaultValue) const;
    270270
    271271    // Parses the specified string for this InputType, and returns true if it
    … …  
    275275    virtual bool parseToDateComponents(const String&, DateComponents*) const;
    276276
    277     // Create a string representation of the specified InputNumber value for the
     277    // Create a string representation of the specified Decimal value for the
    278278    // input type. If NaN or Infinity is specified, this returns an empty
    279279    // string. This should not be called for types without valueAsNumber.
    280     virtual String serialize(const InputNumber&) const;
     280    virtual String serialize(const Decimal&) const;
    281281
    282282    virtual bool supportsIndeterminateAppearance() const;
    … …  
    292292    void dispatchSimulatedClickIfActive(KeyboardEvent*) const;
    293293    Chrome* chrome() const;
    294     InputNumber parseToNumberOrNaN(const String&) const;
     294    Decimal parseToNumberOrNaN(const String&) const;
    295295
    296296private:

  • trunk/Source/WebCore/html/MonthInputType.cpp

    r119948 r120313  
    8383}
    8484
    85 InputNumber MonthInputType::defaultValueForStepUp() const
     85Decimal MonthInputType::defaultValueForStepUp() const
    8686{
    8787    double current = currentTimeMS();
    … …  
    9595    double months = date.monthsSinceEpoch();
    9696    ASSERT(isfinite(months));
    97     return convertDoubleToInputNumber(months);
     97    return Decimal::fromDouble(months);
    9898}
    9999
    … …  
    102102    DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (monthDefaultStep, monthDefaultStepBase, monthStepScaleFactor, StepRange::ParsedStepValueShouldBeInteger));
    103103
    104     const InputNumber stepBase = parseToNumber(element()->fastGetAttribute(minAttr), convertDoubleToInputNumber(DateComponents::minimumMonth()));
    105     const InputNumber minimum = parseToNumber(element()->fastGetAttribute(minAttr), convertDoubleToInputNumber(DateComponents::minimumMonth()));
    106     const InputNumber maximum = parseToNumber(element()->fastGetAttribute(maxAttr), convertDoubleToInputNumber(DateComponents::maximumMonth()));
    107     const InputNumber step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
     104    const Decimal stepBase = parseToNumber(element()->fastGetAttribute(minAttr), Decimal::fromDouble(DateComponents::minimumMonth()));
     105    const Decimal minimum = parseToNumber(element()->fastGetAttribute(minAttr), Decimal::fromDouble(DateComponents::minimumMonth()));
     106    const Decimal maximum = parseToNumber(element()->fastGetAttribute(maxAttr), Decimal::fromDouble(DateComponents::maximumMonth()));
     107    const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
    108108    return StepRange(stepBase, minimum, maximum, step, stepDescription);
    109109}
    110110
    111 InputNumber MonthInputType::parseToNumber(const String& src, const InputNumber& defaultValue) const
     111Decimal MonthInputType::parseToNumber(const String& src, const Decimal& defaultValue) const
    112112{
    113113    DateComponents date;
    … …  
    116116    double months = date.monthsSinceEpoch();
    117117    ASSERT(isfinite(months));
    118     return convertDoubleToInputNumber(months);
     118    return Decimal::fromDouble(months);
    119119}
    120120

  • trunk/Source/WebCore/html/MonthInputType.h

    r119540 r120313  
    4848    virtual double valueAsDate() const OVERRIDE;
    4949    virtual String serializeWithMilliseconds(double) const OVERRIDE;
    50     virtual InputNumber parseToNumber(const String&, const InputNumber&) const OVERRIDE;
    51     virtual InputNumber defaultValueForStepUp() const OVERRIDE;
     50    virtual Decimal parseToNumber(const String&, const Decimal&) const OVERRIDE;
     51    virtual Decimal defaultValueForStepUp() const OVERRIDE;
    5252    virtual StepRange createStepRange(AnyStepHandling) const OVERRIDE;
    5353    virtual bool parseToDateComponentsInternal(const UChar*, unsigned length, DateComponents*) const OVERRIDE;

  • trunk/Source/WebCore/html/NumberInputType.cpp

    r119948 r120313  
    125125}
    126126
    127 void NumberInputType::setValueAsInputNumber(const InputNumber& newValue, TextFieldEventBehavior eventBehavior, ExceptionCode& ec) const
     127void NumberInputType::setValueAsDecimal(const Decimal& newValue, TextFieldEventBehavior eventBehavior, ExceptionCode& ec) const
    128128{
    129129    // FIXME: We should use numeric_limits<double>::max for number input type.
    130     const InputNumber floatMax = convertDoubleToInputNumber(numeric_limits<float>::max());
     130    const Decimal floatMax = Decimal::fromDouble(numeric_limits<float>::max());
    131131    if (newValue < -floatMax) {
    132132        ec = INVALID_STATE_ERR;
    … …  
    154154{
    155155    DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (numberDefaultStep, numberDefaultStepBase, numberStepScaleFactor));
    156     const InputNumber stepBase = parseToDecimalForNumberType(element()->fastGetAttribute(minAttr), numberDefaultStepBase);
     156    const Decimal stepBase = parseToDecimalForNumberType(element()->fastGetAttribute(minAttr), numberDefaultStepBase);
    157157    // FIXME: We should use numeric_limits<double>::max for number input type.
    158     const InputNumber floatMax = convertDoubleToInputNumber(numeric_limits<float>::max());
    159     const InputNumber minimum = parseToNumber(element()->fastGetAttribute(minAttr), -floatMax);
    160     const InputNumber maximum = parseToNumber(element()->fastGetAttribute(maxAttr), floatMax);
    161     const InputNumber step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
     158    const Decimal floatMax = Decimal::fromDouble(numeric_limits<float>::max());
     159    const Decimal minimum = parseToNumber(element()->fastGetAttribute(minAttr), -floatMax);
     160    const Decimal maximum = parseToNumber(element()->fastGetAttribute(maxAttr), floatMax);
     161    const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
    162162    return StepRange(stepBase, minimum, maximum, step, stepDescription);
    163163}
    … …  
    206206}
    207207
    208 InputNumber NumberInputType::parseToNumber(const String& src, const InputNumber& defaultValue) const
     208Decimal NumberInputType::parseToNumber(const String& src, const Decimal& defaultValue) const
    209209{
    210210    return parseToDecimalForNumberType(src, defaultValue);
    211211}
    212212
    213 String NumberInputType::serialize(const InputNumber& value) const
     213String NumberInputType::serialize(const Decimal& value) const
    214214{
    215215    if (!value.isFinite())

  • trunk/Source/WebCore/html/NumberInputType.h

    r119948 r120313  
    4545    virtual double valueAsDouble() const OVERRIDE;
    4646    virtual void setValueAsDouble(double, TextFieldEventBehavior, ExceptionCode&) const OVERRIDE;
    47     virtual void setValueAsInputNumber(const InputNumber&, TextFieldEventBehavior, ExceptionCode&) const OVERRIDE;
     47    virtual void setValueAsDecimal(const Decimal&, TextFieldEventBehavior, ExceptionCode&) const OVERRIDE;
    4848    virtual bool typeMismatchFor(const String&) const OVERRIDE;
    4949    virtual bool typeMismatch() const OVERRIDE;
    … …  
    5353    virtual void handleKeydownEvent(KeyboardEvent*) OVERRIDE;
    5454    virtual void handleWheelEvent(WheelEvent*) OVERRIDE;
    55     virtual InputNumber parseToNumber(const String&, const InputNumber&) const OVERRIDE;
    56     virtual String serialize(const InputNumber&) const OVERRIDE;
     55    virtual Decimal parseToNumber(const String&, const Decimal&) const OVERRIDE;
     56    virtual String serialize(const Decimal&) const OVERRIDE;
    5757    virtual void handleBlurEvent() OVERRIDE;
    5858    virtual String localizeValue(const String&) const OVERRIDE;

  • trunk/Source/WebCore/html/RangeInputType.cpp

    r119948 r120313  
    6161static const int rangeStepScaleFactor = 1;
    6262
    63 static InputNumber ensureMaximum(const InputNumber& proposedValue, const InputNumber& minimum, const InputNumber& fallbackValue)
     63static Decimal ensureMaximum(const Decimal& proposedValue, const Decimal& minimum, const Decimal& fallbackValue)
    6464{
    6565    return proposedValue >= minimum ? proposedValue : std::max(minimum, fallbackValue);
    … …  
    8686}
    8787
    88 void RangeInputType::setValueAsInputNumber(const InputNumber& newValue, TextFieldEventBehavior eventBehavior, ExceptionCode&) const
     88void RangeInputType::setValueAsDecimal(const Decimal& newValue, TextFieldEventBehavior eventBehavior, ExceptionCode&) const
    8989{
    9090    element()->setValue(serialize(newValue), eventBehavior);
    … …  
    100100    DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (rangeDefaultStep, rangeDefaultStepBase, rangeStepScaleFactor));
    101101
    102     const InputNumber minimum = parseToNumber(element()->fastGetAttribute(minAttr), rangeDefaultMinimum);
    103     const InputNumber maximum = ensureMaximum(parseToNumber(element()->fastGetAttribute(maxAttr), rangeDefaultMaximum), minimum, rangeDefaultMaximum);
     102    const Decimal minimum = parseToNumber(element()->fastGetAttribute(minAttr), rangeDefaultMinimum);
     103    const Decimal maximum = ensureMaximum(parseToNumber(element()->fastGetAttribute(maxAttr), rangeDefaultMaximum), minimum, rangeDefaultMaximum);
    104104
    105105    const AtomicString& precisionValue = element()->fastGetAttribute(precisionAttr);
    106106    if (!precisionValue.isNull()) {
    107         const InputNumber step = equalIgnoringCase(precisionValue, "float") ? Decimal::nan() : 1;
     107        const Decimal step = equalIgnoringCase(precisionValue, "float") ? Decimal::nan() : 1;
    108108        return StepRange(minimum, minimum, maximum, step, stepDescription);
    109109    }
    110110
    111     const InputNumber step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
     111    const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
    112112    return StepRange(minimum, minimum, maximum, step, stepDescription);
    113113}
    … …  
    142142    const String& key = event->keyIdentifier();
    143143
    144     const InputNumber current = parseToNumberOrNaN(element()->value());
     144    const Decimal current = parseToNumberOrNaN(element()->value());
    145145    ASSERT(current.isFinite());
    146146
    … …  
    150150    // FIXME: We can't use stepUp() for the step value "any". So, we increase
    151151    // or decrease the value by 1/100 of the value range. Is it reasonable?
    152     const InputNumber step = equalIgnoringCase(element()->fastGetAttribute(stepAttr), "any") ? (stepRange.maximum() - stepRange.minimum()) / 100 : stepRange.step();
    153     const InputNumber bigStep = max((stepRange.maximum() - stepRange.minimum()) / 10, step);
     152    const Decimal step = equalIgnoringCase(element()->fastGetAttribute(stepAttr), "any") ? (stepRange.maximum() - stepRange.minimum()) / 100 : stepRange.step();
     153    const Decimal bigStep = max((stepRange.maximum() - stepRange.minimum()) / 10, step);
    154154
    155155    bool isVertical = false;
    … …  
    159159    }
    160160
    161     InputNumber newValue;
     161    Decimal newValue;
    162162    if (key == "Up")
    163163        newValue = current + step;
    … …  
    184184        ExceptionCode ec;
    185185        TextFieldEventBehavior eventBehavior = DispatchChangeEvent;
    186         setValueAsInputNumber(newValue, eventBehavior, ec);
     186        setValueAsDecimal(newValue, eventBehavior, ec);
    187187
    188188        if (AXObjectCache::accessibilityEnabled())
    … …  
    214214}
    215215
    216 InputNumber RangeInputType::parseToNumber(const String& src, const InputNumber& defaultValue) const
     216Decimal RangeInputType::parseToNumber(const String& src, const Decimal& defaultValue) const
    217217{
    218218    return parseToDecimalForNumberType(src, defaultValue);
    219219}
    220220
    221 String RangeInputType::serialize(const InputNumber& value) const
     221String RangeInputType::serialize(const Decimal& value) const
    222222{
    223223    if (!value.isFinite())
    … …  
    264264{
    265265    StepRange stepRange(createStepRange(RejectAny));
    266     const InputNumber proposedNumericValue = parseToNumber(proposedValue, stepRange.defaultValue());
     266    const Decimal proposedNumericValue = parseToNumber(proposedValue, stepRange.defaultValue());
    267267    return serializeForNumberType(stepRange.clampValue(proposedNumericValue));
    268268}

  • trunk/Source/WebCore/html/RangeInputType.h

    r119540 r120313  
    4747    virtual const AtomicString& formControlType() const OVERRIDE;
    4848    virtual double valueAsDouble() const OVERRIDE;
    49     virtual void setValueAsInputNumber(const InputNumber&, TextFieldEventBehavior, ExceptionCode&) const OVERRIDE;
     49    virtual void setValueAsDecimal(const Decimal&, TextFieldEventBehavior, ExceptionCode&) const OVERRIDE;
    5050    virtual bool supportsRequired() const OVERRIDE;
    5151    virtual StepRange createStepRange(AnyStepHandling) const OVERRIDE;
    … …  
    5555    virtual RenderObject* createRenderer(RenderArena*, RenderStyle*) const OVERRIDE;
    5656    virtual void createShadowSubtree() OVERRIDE;
    57     virtual InputNumber parseToNumber(const String&, const InputNumber&) const OVERRIDE;
    58     virtual String serialize(const InputNumber&) const OVERRIDE;
     57    virtual Decimal parseToNumber(const String&, const Decimal&) const OVERRIDE;
     58    virtual String serialize(const Decimal&) const OVERRIDE;
    5959    virtual void accessKeyAction(bool sendMouseEvents) OVERRIDE;
    6060    virtual void minOrMaxAttributeChanged() OVERRIDE;

  • trunk/Source/WebCore/html/StepRange.cpp

    r119948 r120313  
    5252}
    5353
    54 StepRange::StepRange(const InputNumber& stepBase, const InputNumber& minimum, const InputNumber& maximum, const InputNumber& step, const StepDescription& stepDescription)
     54StepRange::StepRange(const Decimal& stepBase, const Decimal& minimum, const Decimal& maximum, const Decimal& step, const StepDescription& stepDescription)
    5555    : m_maximum(maximum)
    5656    , m_minimum(minimum)
    … …  
    6666}
    6767
    68 InputNumber StepRange::acceptableError() const
     68Decimal StepRange::acceptableError() const
    6969{
    7070    // FIXME: We should use DBL_MANT_DIG instead of FLT_MANT_DIG regarding to HTML5 specification.
    … …  
    7373}
    7474
    75 InputNumber StepRange::alignValueForStep(const InputNumber& currentValue, const InputNumber& newValue) const
     75Decimal StepRange::alignValueForStep(const Decimal& currentValue, const Decimal& newValue) const
    7676{
    7777    DEFINE_STATIC_LOCAL(const Decimal, tenPowerOf21, (Decimal::Positive, 21, 1));
    … …  
    8282}
    8383
    84 InputNumber StepRange::clampValue(const InputNumber& value) const
     84Decimal StepRange::clampValue(const Decimal& value) const
    8585{
    86     const InputNumber inRangeValue = max(m_minimum, min(value, m_maximum));
     86    const Decimal inRangeValue = max(m_minimum, min(value, m_maximum));
    8787    if (!m_hasStep)
    8888        return inRangeValue;
    8989    // Rounds inRangeValue to minimum + N * step.
    90     const InputNumber roundedValue = roundByStep(inRangeValue, m_minimum);
    91     const InputNumber clampedValue = roundedValue > m_maximum ? roundedValue - m_step : roundedValue;
     90    const Decimal roundedValue = roundByStep(inRangeValue, m_minimum);
     91    const Decimal clampedValue = roundedValue > m_maximum ? roundedValue - m_step : roundedValue;
    9292    ASSERT(clampedValue >= m_minimum);
    9393    ASSERT(clampedValue <= m_maximum);
    … …  
    9595}
    9696
    97 InputNumber StepRange::parseStep(AnyStepHandling anyStepHandling, const StepDescription& stepDescription, const String& stepString)
     97Decimal StepRange::parseStep(AnyStepHandling anyStepHandling, const StepDescription& stepDescription, const String& stepString)
    9898{
    9999    if (stepString.isEmpty())
    … …  
    137137}
    138138
    139 InputNumber StepRange::roundByStep(const InputNumber& value, const InputNumber& base) const
     139Decimal StepRange::roundByStep(const Decimal& value, const Decimal& base) const
    140140{
    141141    return base + ((value - base) / m_step).round() * m_step;
    142142}
    143143
    144 bool StepRange::stepMismatch(const InputNumber& valueForCheck) const
     144bool StepRange::stepMismatch(const Decimal& valueForCheck) const
    145145{
    146146    if (!m_hasStep)
    … …  
    148148    if (!valueForCheck.isFinite())
    149149        return false;
    150     const InputNumber value = (valueForCheck - m_stepBase).abs();
     150    const Decimal value = (valueForCheck - m_stepBase).abs();
    151151    if (!value.isFinite())
    152152        return false;
    153     // InputNumber's fractional part size is DBL_MAN_DIG-bit. If the current value
     153    // Decimal's fractional part size is DBL_MAN_DIG-bit. If the current value
    154154    // is greater than step*2^DBL_MANT_DIG, the following computation for
    155155    // remainder makes no sense.
    … …  
    160160    // ... that number subtracted from the step base is not an integral multiple
    161161    // of the allowed value step, the element is suffering from a step mismatch.
    162     const InputNumber remainder = (value - m_step * (value / m_step).round()).abs();
     162    const Decimal remainder = (value - m_step * (value / m_step).round()).abs();
    163163    // Accepts erros in lower fractional part which IEEE 754 single-precision
    164164    // can't represent.
    165     const InputNumber computedAcceptableError = acceptableError();
     165    const Decimal computedAcceptableError = acceptableError();
    166166    return computedAcceptableError < remainder && remainder < (m_step - computedAcceptableError);
    167167}

  • trunk/Source/WebCore/html/StepRange.h

    r119948 r120313  
    3232enum AnyStepHandling { RejectAny, AnyIsDefaultStep };
    3333
    34 // FIXME: We should rename InputNumber to Decimal in all places.
    35 typedef Decimal InputNumber;
    36 
    37 inline InputNumber convertDoubleToInputNumber(double doubleValue)
    38 {
    39     return Decimal::fromDouble(doubleValue);
    40 }
    41 
    42 inline double convertInputNumberToDouble(const InputNumber& numericValue)
    43 {
    44     return numericValue.toDouble();
    45 }
    46 
    4734class StepRange {
    4835public:
    … …  
    7562        }
    7663
    77         InputNumber defaultValue() const
     64        Decimal defaultValue() const
    7865        {
    7966            return defaultStep * stepScaleFactor;
    … …  
    8370    StepRange();
    8471    StepRange(const StepRange&);
    85     StepRange(const InputNumber& stepBase, const InputNumber& minimum, const InputNumber& maximum, const InputNumber& step, const StepDescription&);
    86     InputNumber acceptableError() const;
    87     InputNumber alignValueForStep(const InputNumber& currentValue, const InputNumber& newValue) const;
    88     InputNumber clampValue(const InputNumber& value) const;
     72    StepRange(const Decimal& stepBase, const Decimal& minimum, const Decimal& maximum, const Decimal& step, const StepDescription&);
     73    Decimal acceptableError() const;
     74    Decimal alignValueForStep(const Decimal& currentValue, const Decimal& newValue) const;
     75    Decimal clampValue(const Decimal& value) const;
    8976    bool hasStep() const { return m_hasStep; }
    90     InputNumber maximum() const { return m_maximum; }
    91     InputNumber minimum() const { return m_minimum; }
    92     static InputNumber parseStep(AnyStepHandling, const StepDescription&, const String&);
    93     InputNumber step() const { return m_step; }
    94     InputNumber stepBase() const { return m_stepBase; }
     77    Decimal maximum() const { return m_maximum; }
     78    Decimal minimum() const { return m_minimum; }
     79    static Decimal parseStep(AnyStepHandling, const StepDescription&, const String&);
     80    Decimal step() const { return m_step; }
     81    Decimal stepBase() const { return m_stepBase; }
    9582    int stepScaleFactor() const { return m_stepDescription.stepScaleFactor; }
    96     bool stepMismatch(const InputNumber&) const;
     83    bool stepMismatch(const Decimal&) const;
    9784
    9885    // Clamp the middle value according to the step
    99     InputNumber defaultValue() const
     86    Decimal defaultValue() const
    10087    {
    10188        return clampValue((m_minimum + m_maximum) / 2);
    … …  
    10390
    10491    // Map value into 0-1 range
    105     InputNumber proportionFromValue(const InputNumber& value) const
     92    Decimal proportionFromValue(const Decimal& value) const
    10693    {
    10794        if (m_minimum == m_maximum)
    … …  
    11299
    113100    // Map from 0-1 range to value
    114     InputNumber valueFromProportion(const InputNumber& proportion) const
     101    Decimal valueFromProportion(const Decimal& proportion) const
    115102    {
    116103        return m_minimum + proportion * (m_maximum - m_minimum);
    … …  
    119106private:
    120107    StepRange& operator =(const StepRange&);
    121     InputNumber roundByStep(const InputNumber& value, const InputNumber& base) const;
     108    Decimal roundByStep(const Decimal& value, const Decimal& base) const;
    122109
    123     const InputNumber m_maximum; // maximum must be >= minimum.
    124     const InputNumber m_minimum;
    125     const InputNumber m_step;
    126     const InputNumber m_stepBase;
     110    const Decimal m_maximum; // maximum must be >= minimum.
     111    const Decimal m_minimum;
     112    const Decimal m_step;
     113    const Decimal m_stepBase;
    127114    const StepDescription m_stepDescription;
    128115    const bool m_hasStep;

  • trunk/Source/WebCore/html/TimeInputType.cpp

    r119948 r120313  
    6565}
    6666
    67 InputNumber TimeInputType::defaultValueForStepUp() const
     67Decimal TimeInputType::defaultValueForStepUp() const
    6868{
    6969    double current = currentTimeMS();
    … …  
    7777    double milliseconds = date.millisecondsSinceEpoch();
    7878    ASSERT(isfinite(milliseconds));
    79     return convertDoubleToInputNumber(milliseconds);
     79    return Decimal::fromDouble(milliseconds);
    8080}
    8181
    … …  
    8484    DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (timeDefaultStep, timeDefaultStepBase, timeStepScaleFactor, StepRange::ScaledStepValueShouldBeInteger));
    8585
    86     const InputNumber stepBase = parseToNumber(element()->fastGetAttribute(minAttr), 0);
    87     const InputNumber minimum = parseToNumber(element()->fastGetAttribute(minAttr), convertDoubleToInputNumber(DateComponents::minimumTime()));
    88     const InputNumber maximum = parseToNumber(element()->fastGetAttribute(maxAttr), convertDoubleToInputNumber(DateComponents::maximumTime()));
    89     const InputNumber step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
     86    const Decimal stepBase = parseToNumber(element()->fastGetAttribute(minAttr), 0);
     87    const Decimal minimum = parseToNumber(element()->fastGetAttribute(minAttr), Decimal::fromDouble(DateComponents::minimumTime()));
     88    const Decimal maximum = parseToNumber(element()->fastGetAttribute(maxAttr), Decimal::fromDouble(DateComponents::maximumTime()));
     89    const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
    9090    return StepRange(stepBase, minimum, maximum, step, stepDescription);
    9191}

  • trunk/Source/WebCore/html/TimeInputType.h

    r119540 r120313  
    4646    virtual const AtomicString& formControlType() const OVERRIDE;
    4747    virtual DateComponents::Type dateType() const OVERRIDE;
    48     virtual InputNumber defaultValueForStepUp() const OVERRIDE;
     48    virtual Decimal defaultValueForStepUp() const OVERRIDE;
    4949    virtual StepRange createStepRange(AnyStepHandling) const OVERRIDE;
    5050    virtual bool parseToDateComponentsInternal(const UChar*, unsigned length, DateComponents*) const OVERRIDE;

  • trunk/Source/WebCore/html/WeekInputType.cpp

    r119948 r120313  
    6666    DEFINE_STATIC_LOCAL(const StepRange::StepDescription, stepDescription, (weekDefaultStep, weekDefaultStepBase, weekStepScaleFactor, StepRange::ParsedStepValueShouldBeInteger));
    6767
    68     const InputNumber stepBase = parseToNumber(element()->fastGetAttribute(minAttr), weekDefaultStepBase);
    69     const InputNumber minimum = parseToNumber(element()->fastGetAttribute(minAttr), convertDoubleToInputNumber(DateComponents::minimumWeek()));
    70     const InputNumber maximum = parseToNumber(element()->fastGetAttribute(maxAttr), convertDoubleToInputNumber(DateComponents::maximumWeek()));
    71     const InputNumber step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
     68    const Decimal stepBase = parseToNumber(element()->fastGetAttribute(minAttr), weekDefaultStepBase);
     69    const Decimal minimum = parseToNumber(element()->fastGetAttribute(minAttr), Decimal::fromDouble(DateComponents::minimumWeek()));
     70    const Decimal maximum = parseToNumber(element()->fastGetAttribute(maxAttr), Decimal::fromDouble(DateComponents::maximumWeek()));
     71    const Decimal step = StepRange::parseStep(anyStepHandling, stepDescription, element()->fastGetAttribute(stepAttr));
    7272    return StepRange(stepBase, minimum, maximum, step, stepDescription);
    7373}

  • trunk/Source/WebCore/html/shadow/CalendarPickerElement.cpp

    r119540 r120313  
    209209    date.setMillisecondsSinceEpochForDate(input->maximum());
    210210    String maxString = date.toString();
    211     InputNumber step;
     211    Decimal step;
    212212    String stepString = input->fastGetAttribute(stepAttr);
    213213    if (stepString.isEmpty() || !input->getAllowedValueStep(&step))

  • trunk/Source/WebCore/html/shadow/SliderThumbElement.cpp

    r120246 r120313  
    5252namespace WebCore {
    5353
    54 inline static InputNumber sliderPosition(HTMLInputElement* element)
     54inline static Decimal sliderPosition(HTMLInputElement* element)
    5555{
    5656    const StepRange stepRange(element->createStepRange(RejectAny));
    57     const InputNumber oldValue = parseToDecimalForNumberType(element->value(), stepRange.defaultValue());
     57    const Decimal oldValue = parseToDecimalForNumberType(element->value(), stepRange.defaultValue());
    5858    return stepRange.proportionFromValue(stepRange.clampValue(oldValue));
    5959}
    … …  
    117117    bool isVertical = hasVerticalAppearance(input);
    118118
    119     double fraction = convertInputNumberToDouble(sliderPosition(input) * 100);
     119    double fraction = (sliderPosition(input) * 100).toDouble();
    120120    if (isVertical)
    121121        style()->setTop(Length(100 - fraction, Percent));
    … …  
    243243        return;
    244244
    245     const InputNumber ratio = convertDoubleToInputNumber(static_cast<double>(position) / trackSize);
    246     const InputNumber fraction = isVertical || !renderBox()->style()->isLeftToRightDirection() ? InputNumber(1) - ratio : ratio;
     245    const Decimal ratio = Decimal::fromDouble(static_cast<double>(position) / trackSize);
     246    const Decimal fraction = isVertical || !renderBox()->style()->isLeftToRightDirection() ? Decimal(1) - ratio : ratio;
    247247    StepRange stepRange(input->createStepRange(RejectAny));
    248     const InputNumber value = stepRange.clampValue(stepRange.valueFromProportion(fraction));
     248    const Decimal value = stepRange.clampValue(stepRange.valueFromProportion(fraction));
    249249
    250250    // FIXME: This is no longer being set from renderer. Consider updating the method name.
Note: See TracChangeset for help on using the changeset viewer.