Use NeverDestroyed instead of DEPRECATED_DEFINE_STATIC_LOCAL
[WebKit-https.git] / Source / WebCore / html / StepRange.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Library General Public
6  * License as published by the Free Software Foundation; either
7  * version 2 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Library General Public License for more details.
13  *
14  * You should have received a copy of the GNU Library General Public License
15  * along with this library; see the file COPYING.LIB.  If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17  * Boston, MA 02110-1301, USA.
18  *
19  */
20
21 #include "config.h"
22 #include "StepRange.h"
23
24 #include "HTMLNames.h"
25 #include "HTMLParserIdioms.h"
26 #include <wtf/MathExtras.h>
27 #include <wtf/NeverDestroyed.h>
28
29 namespace WebCore {
30
31 using namespace HTMLNames;
32
33 StepRange::StepRange()
34     : m_maximum(100)
35     , m_minimum(0)
36     , m_step(1)
37     , m_stepBase(0)
38     , m_hasStep(false)
39 {
40 }
41
42 StepRange::StepRange(const StepRange& stepRange)
43     : m_maximum(stepRange.m_maximum)
44     , m_minimum(stepRange.m_minimum)
45     , m_step(stepRange.m_step)
46     , m_stepBase(stepRange.m_stepBase)
47     , m_stepDescription(stepRange.m_stepDescription)
48     , m_hasStep(stepRange.m_hasStep)
49 {
50 }
51
52 StepRange::StepRange(const Decimal& stepBase, const Decimal& minimum, const Decimal& maximum, const Decimal& step, const StepDescription& stepDescription)
53     : m_maximum(maximum)
54     , m_minimum(minimum)
55     , m_step(step.isFinite() ? step : 1)
56     , m_stepBase(stepBase.isFinite() ? stepBase : 1)
57     , m_stepDescription(stepDescription)
58     , m_hasStep(step.isFinite())
59 {
60     ASSERT(m_maximum.isFinite());
61     ASSERT(m_minimum.isFinite());
62     ASSERT(m_step.isFinite());
63     ASSERT(m_stepBase.isFinite());
64 }
65
66 Decimal StepRange::acceptableError() const
67 {
68     // FIXME: We should use DBL_MANT_DIG instead of FLT_MANT_DIG regarding to HTML5 specification.
69     static NeverDestroyed<const Decimal> twoPowerOfFloatMantissaBits(Decimal::Positive, 0, UINT64_C(1) << FLT_MANT_DIG);
70     return m_stepDescription.stepValueShouldBe == StepValueShouldBeReal ? m_step / twoPowerOfFloatMantissaBits : Decimal(0);
71 }
72
73 Decimal StepRange::alignValueForStep(const Decimal& currentValue, const Decimal& newValue) const
74 {
75     static NeverDestroyed<const Decimal> tenPowerOf21(Decimal::Positive, 21, 1);
76     if (newValue >= tenPowerOf21)
77         return newValue;
78
79     return stepMismatch(currentValue) ? newValue : roundByStep(newValue, m_stepBase);
80 }
81
82 Decimal StepRange::clampValue(const Decimal& value) const
83 {
84     const Decimal inRangeValue = std::max(m_minimum, std::min(value, m_maximum));
85     if (!m_hasStep)
86         return inRangeValue;
87     // Rounds inRangeValue to minimum + N * step.
88     const Decimal roundedValue = roundByStep(inRangeValue, m_minimum);
89     const Decimal clampedValue = roundedValue > m_maximum ? roundedValue - m_step : roundedValue;
90     ASSERT(clampedValue >= m_minimum);
91     ASSERT(clampedValue <= m_maximum);
92     return clampedValue;
93 }
94
95 Decimal StepRange::parseStep(AnyStepHandling anyStepHandling, const StepDescription& stepDescription, const String& stepString)
96 {
97     if (stepString.isEmpty())
98         return stepDescription.defaultValue();
99
100     if (equalIgnoringCase(stepString, "any")) {
101         switch (anyStepHandling) {
102         case RejectAny:
103             return Decimal::nan();
104         case AnyIsDefaultStep:
105             return stepDescription.defaultValue();
106         default:
107             ASSERT_NOT_REACHED();
108         }
109     }
110
111     Decimal step = parseToDecimalForNumberType(stepString);
112     if (!step.isFinite() || step <= 0)
113         return stepDescription.defaultValue();
114
115     switch (stepDescription.stepValueShouldBe) {
116     case StepValueShouldBeReal:
117         step *= stepDescription.stepScaleFactor;
118         break;
119     case ParsedStepValueShouldBeInteger:
120         // For date, month, and week, the parsed value should be an integer for some types.
121         step = std::max(step.round(), Decimal(1));
122         step *= stepDescription.stepScaleFactor;
123         break;
124     case ScaledStepValueShouldBeInteger:
125         // For datetime, datetime-local, time, the result should be an integer.
126         step *= stepDescription.stepScaleFactor;
127         step = std::max(step.round(), Decimal(1));
128         break;
129     default:
130         ASSERT_NOT_REACHED();
131     }
132
133     ASSERT(step > 0);
134     return step;
135 }
136
137 Decimal StepRange::roundByStep(const Decimal& value, const Decimal& base) const
138 {
139     return base + ((value - base) / m_step).round() * m_step;
140 }
141
142 bool StepRange::stepMismatch(const Decimal& valueForCheck) const
143 {
144     if (!m_hasStep)
145         return false;
146     if (!valueForCheck.isFinite())
147         return false;
148     const Decimal value = (valueForCheck - m_stepBase).abs();
149     if (!value.isFinite())
150         return false;
151     // Decimal's fractional part size is DBL_MAN_DIG-bit. If the current value
152     // is greater than step*2^DBL_MANT_DIG, the following computation for
153     // remainder makes no sense.
154     static NeverDestroyed<const Decimal> twoPowerOfDoubleMantissaBits(Decimal::Positive, 0, UINT64_C(1) << DBL_MANT_DIG);
155     if (value / twoPowerOfDoubleMantissaBits > m_step)
156         return false;
157     // The computation follows HTML5 4.10.7.2.10 `The step attribute' :
158     // ... that number subtracted from the step base is not an integral multiple
159     // of the allowed value step, the element is suffering from a step mismatch.
160     const Decimal remainder = (value - m_step * (value / m_step).round()).abs();
161     // Accepts erros in lower fractional part which IEEE 754 single-precision
162     // can't represent.
163     const Decimal computedAcceptableError = acceptableError();
164     return computedAcceptableError < remainder && remainder < (m_step - computedAcceptableError);
165 }
166
167 } // namespace WebCore