Web Automation: elements larger than the viewport have incorrect in-view center point
[WebKit-https.git] / Source / WebCore / platform / CalculationValue.cpp
1 /*
2  * Copyright (C) 2011 Google Inc. All rights reserved.
3  * Copyright (C) 2014 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "config.h"
33 #include "CalculationValue.h"
34
35 #include "LengthFunctions.h"
36 #include <limits>
37 #include <wtf/text/TextStream.h>
38
39 namespace WebCore {
40
41 Ref<CalculationValue> CalculationValue::create(std::unique_ptr<CalcExpressionNode> value, ValueRange range)
42 {
43     return adoptRef(*new CalculationValue(WTFMove(value), range));
44 }
45
46 float CalcExpressionNumber::evaluate(float) const
47 {
48     return m_value;
49 }
50
51 void CalcExpressionNumber::dump(TextStream& ts) const
52 {
53     ts << TextStream::FormatNumberRespectingIntegers(m_value);
54 }
55
56 bool CalcExpressionNumber::operator==(const CalcExpressionNode& other) const
57 {
58     return other.type() == CalcExpressionNodeType::Number && *this == toCalcExpressionNumber(other);
59 }
60
61 float CalculationValue::evaluate(float maxValue) const
62 {
63     float result = m_expression->evaluate(maxValue);
64     // FIXME: This test was originally needed when we did not detect division by zero at parse time.
65     // It's possible that this is now unneeded code and can be removed.
66     if (std::isnan(result))
67         return 0;
68     return m_shouldClampToNonNegative && result < 0 ? 0 : result;
69 }
70
71 float CalcExpressionOperation::evaluate(float maxValue) const
72 {
73     switch (m_operator) {
74     case CalcOperator::Add: {
75         ASSERT(m_children.size() == 2);
76         float left = m_children[0]->evaluate(maxValue);
77         float right = m_children[1]->evaluate(maxValue);
78         return left + right;
79     }
80     case CalcOperator::Subtract: {
81         ASSERT(m_children.size() == 2);
82         float left = m_children[0]->evaluate(maxValue);
83         float right = m_children[1]->evaluate(maxValue);
84         return left - right;
85     }
86     case CalcOperator::Multiply: {
87         ASSERT(m_children.size() == 2);
88         float left = m_children[0]->evaluate(maxValue);
89         float right = m_children[1]->evaluate(maxValue);
90         return left * right;
91     }
92     case CalcOperator::Divide: {
93         ASSERT(m_children.size() == 1 || m_children.size() == 2);
94         if (m_children.size() == 1)
95             return std::numeric_limits<float>::quiet_NaN();
96         float left = m_children[0]->evaluate(maxValue);
97         float right = m_children[1]->evaluate(maxValue);
98         return left / right;
99     }
100     case CalcOperator::Min: {
101         if (m_children.isEmpty())
102             return std::numeric_limits<float>::quiet_NaN();
103         float minimum = m_children[0]->evaluate(maxValue);
104         for (auto& child : m_children)
105             minimum = std::min(minimum, child->evaluate(maxValue));
106         return minimum;
107     }
108     case CalcOperator::Max: {
109         if (m_children.isEmpty())
110             return std::numeric_limits<float>::quiet_NaN();
111         float maximum = m_children[0]->evaluate(maxValue);
112         for (auto& child : m_children)
113             maximum = std::max(maximum, child->evaluate(maxValue));
114         return maximum;
115     }
116     }
117     ASSERT_NOT_REACHED();
118     return std::numeric_limits<float>::quiet_NaN();
119 }
120
121 bool CalcExpressionOperation::operator==(const CalcExpressionNode& other) const
122 {
123     return other.type() == CalcExpressionNodeType::Operation && *this == toCalcExpressionOperation(other);
124 }
125
126 bool operator==(const CalcExpressionOperation& a, const CalcExpressionOperation& b)
127 {
128     if (a.getOperator() != b.getOperator())
129         return false;
130     // Maybe Vectors of unique_ptrs should always do deep compare?
131     if (a.children().size() != b.children().size())
132         return false;
133     for (unsigned i = 0; i < a.children().size(); ++i) {
134         if (!(*a.children()[i] == *b.children()[i]))
135             return false;
136     }
137     return true;
138 }
139
140 void CalcExpressionOperation::dump(TextStream& ts) const
141 {
142     if (m_operator == CalcOperator::Min || m_operator == CalcOperator::Max) {
143         ts << m_operator << "(";
144         size_t childrenCount = m_children.size();
145         for (size_t i = 0; i < childrenCount; i++) {
146             ts << m_children[i].get();
147             if (i < childrenCount - 1)
148                 ts << ", ";
149         }
150         ts << ")";
151     } else
152         ts << m_children[0].get() << " " << m_operator << " " << m_children[1].get();
153 }
154
155 float CalcExpressionLength::evaluate(float maxValue) const
156 {
157     return floatValueForLength(m_length, maxValue);
158 }
159
160 bool CalcExpressionLength::operator==(const CalcExpressionNode& other) const
161 {
162     return other.type() == CalcExpressionNodeType::Length && *this == toCalcExpressionLength(other);
163 }
164
165 void CalcExpressionLength::dump(TextStream& ts) const
166 {
167     ts << m_length;
168 }
169
170 CalcExpressionBlendLength::CalcExpressionBlendLength(Length from, Length to, float progress)
171     : CalcExpressionNode(CalcExpressionNodeType::BlendLength)
172     , m_from(from)
173     , m_to(to)
174     , m_progress(progress)
175 {
176     // Flatten nesting of CalcExpressionBlendLength as a speculative fix for rdar://problem/30533005.
177     // CalcExpressionBlendLength is only used as a result of animation and they don't nest in normal cases.
178     if (m_from.isCalculated() && m_from.calculationValue().expression().type() == CalcExpressionNodeType::BlendLength)
179         m_from = toCalcExpressionBlendLength(m_from.calculationValue().expression()).from();
180     if (m_to.isCalculated() && m_to.calculationValue().expression().type() == CalcExpressionNodeType::BlendLength)
181         m_to = toCalcExpressionBlendLength(m_to.calculationValue().expression()).to();
182 }
183
184 float CalcExpressionBlendLength::evaluate(float maxValue) const
185 {
186     return (1.0f - m_progress) * floatValueForLength(m_from, maxValue) + m_progress * floatValueForLength(m_to, maxValue);
187 }
188
189 bool CalcExpressionBlendLength::operator==(const CalcExpressionNode& other) const
190 {
191     return other.type() == CalcExpressionNodeType::BlendLength && *this == toCalcExpressionBlendLength(other);
192 }
193
194 void CalcExpressionBlendLength::dump(TextStream& ts) const
195 {
196     ts << "blend(" << m_from << ", " << m_to << ", " << m_progress << ")";
197 }
198
199 TextStream& operator<<(TextStream& ts, CalcOperator op)
200 {
201     switch (op) {
202     case CalcOperator::Add: ts << "+"; break;
203     case CalcOperator::Subtract: ts << "-"; break;
204     case CalcOperator::Multiply: ts << "*"; break;
205     case CalcOperator::Divide: ts << "/"; break;
206     case CalcOperator::Min: ts << "max"; break;
207     case CalcOperator::Max: ts << "min"; break;
208     }
209     return ts;
210 }
211
212 TextStream& operator<<(TextStream& ts, const CalculationValue& value)
213 {
214     ts << "calc(";
215     ts << value.expression();
216     ts << ")";
217     return ts;
218 }
219
220 TextStream& operator<<(TextStream& ts, const CalcExpressionNode& expressionNode)
221 {
222     expressionNode.dump(ts);
223     return ts;
224 }
225
226 } // namespace WebCore