LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-08-15 16:30:36 +03:00
Code Issues Packages Projects Releases Wiki Activity

LibWeb: Declare optional parse results inlined in if statements

Browse Source
This commit is contained in:
Bastiaan van der Plaat 2023-12-07 18:40:54 +01:00 committed by Tim Flynn
parent 1b9a961fb0
commit 3bfc2f5e95
Notes: sideshowbarker 2024-07-18 03:20:18 +09:00 
Author: https://github.com/bplaat
Commit: https://github.com/SerenityOS/serenity/commit/3bfc2f5e95
Pull-request: https://github.com/SerenityOS/serenity/pull/22195
Reviewed-by: https://github.com/trflynn89 ✅
5 changed files with 40 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Userland/Libraries/LibWeb/HTML/HTMLInputElement.cpp
View File

@ -1166,11 +1166,9 @@ i32 HTMLInputElement::default_tab_index_value() const
unsigned HTMLInputElement::size() const
{
// The size IDL attribute is limited to only positive numbers and has a default value of 20.
auto maybe_size_string = get_attribute(HTML::AttributeNames::size);
if (maybe_size_string.has_value()) {
auto maybe_size = parse_non_negative_integer(maybe_size_string.value());
if (maybe_size.has_value())
return maybe_size.value();
if (auto size_string = get_attribute(HTML::AttributeNames::size); size_string.has_value()) {
if (auto size = parse_non_negative_integer(*size_string); size.has_value())
return *size;
}
return 20;
}

49
Userland/Libraries/LibWeb/HTML/HTMLMeterElement.cpp
View File

@ -38,11 +38,9 @@ double HTMLMeterElement::value() const
{
// If the value attribute is specified and a value could be parsed out of it, then that value is the candidate actual value. Otherwise, the candidate actual value is zero.
double candidate_value = 0.0;
auto maybe_value_string = get_attribute(HTML::AttributeNames::value);
if (maybe_value_string.has_value()) {
auto maybe_value = parse_floating_point_number(maybe_value_string.value());
if (maybe_value.has_value())
candidate_value = maybe_value.value();
if (auto value_string = get_attribute(HTML::AttributeNames::value); value_string.has_value()) {
if (auto value = parse_floating_point_number(*value_string); value.has_value())
candidate_value = *value;
}
// If the candidate actual value is less than the minimum value, then the actual value is the minimum value.
@ -63,11 +61,9 @@ WebIDL::ExceptionOr<void> HTMLMeterElement::set_value(double value)
double HTMLMeterElement::min() const
{
// If the min attribute is specified and a value could be parsed out of it, then the minimum value is that value. Otherwise, the minimum value is zero.
auto maybe_min_string = get_attribute(HTML::AttributeNames::min);
if (maybe_min_string.has_value()) {
auto maybe_min = parse_floating_point_number(maybe_min_string.value());
if (maybe_min.has_value())
return maybe_min.value();
if (auto min_string = get_attribute(HTML::AttributeNames::min); min_string.has_value()) {
if (auto min = parse_floating_point_number(*min_string); min.has_value())
return *min;
}
return 0;
}
@ -85,11 +81,9 @@ double HTMLMeterElement::max() const
{
// If the max attribute is specified and a value could be parsed out of it, then the candidate maximum value is that value. Otherwise, the candidate maximum value is 1.0.
double candidate_max = 1.0;
auto maybe_max_string = get_attribute(HTML::AttributeNames::max);
if (maybe_max_string.has_value()) {
auto maybe_max = parse_floating_point_number(maybe_max_string.value());
if (maybe_max.has_value())
candidate_max = maybe_max.value();
if (auto max_string = get_attribute(HTML::AttributeNames::max); max_string.has_value()) {
if (auto max = parse_floating_point_number(*max_string); max.has_value())
candidate_max = *max;
}
// If the candidate maximum value is greater than or equal to the minimum value, then the maximum value is the candidate maximum value. Otherwise, the maximum value is the same as the minimum value.
@ -109,11 +103,9 @@ double HTMLMeterElement::low() const
{
// If the low attribute is specified and a value could be parsed out of it, then the candidate low boundary is that value. Otherwise, the candidate low boundary is the same as the minimum value.
double candidate_low = min();
auto maybe_low_string = get_attribute(HTML::AttributeNames::low);
if (maybe_low_string.has_value()) {
auto maybe_low = parse_floating_point_number(maybe_low_string.value());
if (maybe_low.has_value())
candidate_low = maybe_low.value();
if (auto low_string = get_attribute(HTML::AttributeNames::low); low_string.has_value()) {
if (auto low = parse_floating_point_number(*low_string); low.has_value())
candidate_low = *low;
}
// If the candidate low boundary is less than the minimum value, then the low boundary is the minimum value.
@ -135,11 +127,9 @@ double HTMLMeterElement::high() const
{
// If the high attribute is specified and a value could be parsed out of it, then the candidate high boundary is that value. Otherwise, the candidate high boundary is the same as the maximum value.
double candidate_high = max();
auto maybe_high_string = get_attribute(HTML::AttributeNames::high);
if (maybe_high_string.has_value()) {
auto maybe_high = parse_floating_point_number(maybe_high_string.value());
if (maybe_high.has_value())
candidate_high = maybe_high.value();
if (auto high_string = get_attribute(HTML::AttributeNames::high); high_string.has_value()) {
if (auto high = parse_floating_point_number(*high_string); high.has_value())
candidate_high = *high;
}
// If the candidate high boundary is less than the low boundary, then the high boundary is the low boundary.
@ -161,11 +151,9 @@ double HTMLMeterElement::optimum() const
{
// If the optimum attribute is specified and a value could be parsed out of it, then the candidate optimum point is that value. Otherwise, the candidate optimum point is the midpoint between the minimum value and the maximum value.
double candidate_optimum = (max() + min()) / 2;
auto maybe_optimum_string = get_attribute(HTML::AttributeNames::optimum);
if (maybe_optimum_string.has_value()) {
auto maybe_optimum = parse_floating_point_number(maybe_optimum_string.value());
if (maybe_optimum.has_value())
candidate_optimum = maybe_optimum.value();
if (auto optimum_string = get_attribute(HTML::AttributeNames::optimum); optimum_string.has_value()) {
if (auto optimum = parse_floating_point_number(*optimum_string); optimum.has_value())
candidate_optimum = *optimum;
}
// If the candidate optimum point is less than the minimum value, then the optimum point is the minimum value.
@ -246,5 +234,4 @@ void HTMLMeterElement::update_meter_value_element()
double position = (value - min) / (max - min) * 100;
MUST(m_meter_value_element->set_attribute(HTML::AttributeNames::style, MUST(String::formatted("width: {}%;", position))));
}
}

24
Userland/Libraries/LibWeb/HTML/HTMLProgressElement.cpp
View File

@ -37,13 +37,11 @@ void HTMLProgressElement::visit_edges(Cell::Visitor& visitor)
// https://html.spec.whatwg.org/multipage/form-elements.html#dom-progress-value
double HTMLProgressElement::value() const
{
auto maybe_value_string = get_attribute(HTML::AttributeNames::value);
if (!maybe_value_string.has_value())
return 0;
auto maybe_value = parse_floating_point_number(maybe_value_string.value());
if (!maybe_value.has_value())
return 0;
return clamp(maybe_value.value(), 0, max());
if (auto value_string = get_attribute(HTML::AttributeNames::value); value_string.has_value()) {
if (auto value = parse_floating_point_number(*value_string); value.has_value())
return clamp(*value, 0, max());
}
return 0;
}
WebIDL::ExceptionOr<void> HTMLProgressElement::set_value(double value)
@ -60,13 +58,11 @@ WebIDL::ExceptionOr<void> HTMLProgressElement::set_value(double value)
// https://html.spec.whatwg.org/multipage/form-elements.html#dom-progress-max
double HTMLProgressElement::max() const
{
auto maybe_max_string = get_attribute(HTML::AttributeNames::max);
if (!maybe_max_string.has_value())
return 1;
auto maybe_max = parse_floating_point_number(maybe_max_string.value());
if (!maybe_max.has_value())
return 1;
return AK::max(maybe_max.value(), 0);
if (auto max_string = get_attribute(HTML::AttributeNames::max); max_string.has_value()) {
if (auto max = parse_floating_point_number(*max_string); max.has_value())
return AK::max(*max, 0);
}
return 1;
}
WebIDL::ExceptionOr<void> HTMLProgressElement::set_max(double value)

8
Userland/Libraries/LibWeb/HTML/HTMLTableColElement.cpp
View File

@ -29,11 +29,9 @@ void HTMLTableColElement::initialize(JS::Realm& realm)
unsigned int HTMLTableColElement::span() const
{
// The span IDL attribute must reflect the content attribute of the same name. It is clamped to the range [1, 1000], and its default value is 1.
auto maybe_span_string = get_attribute(HTML::AttributeNames::span);
if (maybe_span_string.has_value()) {
auto maybe_span = parse_non_negative_integer(maybe_span_string.value());
if (maybe_span.has_value())
return clamp(maybe_span.value(), 1, 1000);
if (auto span_string = get_attribute(HTML::AttributeNames::span); span_string.has_value()) {
if (auto span = parse_non_negative_integer(*span_string); span.has_value())
return clamp(*span, 1, 1000);
}
return 1;
}

16
Userland/Libraries/LibWeb/HTML/HTMLTextAreaElement.cpp
View File

@ -100,11 +100,9 @@ void HTMLTextAreaElement::form_associated_element_was_removed(DOM::Node*)
unsigned HTMLTextAreaElement::cols() const
{
// The cols and rows attributes are limited to only positive numbers with fallback. The cols IDL attribute's default value is 20.
auto maybe_cols_string = get_attribute(HTML::AttributeNames::cols);
if (maybe_cols_string.has_value()) {
auto maybe_cols = parse_non_negative_integer(maybe_cols_string.value());
if (maybe_cols.has_value())
return maybe_cols.value();
if (auto cols_string = get_attribute(HTML::AttributeNames::cols); cols_string.has_value()) {
if (auto cols = parse_non_negative_integer(*cols_string); cols.has_value())
return *cols;
}
return 20;
}
@ -118,11 +116,9 @@ WebIDL::ExceptionOr<void> HTMLTextAreaElement::set_cols(unsigned value)
unsigned HTMLTextAreaElement::rows() const
{
// The cols and rows attributes are limited to only positive numbers with fallback. The rows IDL attribute's default value is 2.
auto maybe_rows_string = get_attribute(HTML::AttributeNames::rows);
if (maybe_rows_string.has_value()) {
auto maybe_rows = parse_non_negative_integer(maybe_rows_string.value());
if (maybe_rows.has_value())
return maybe_rows.value();
if (auto rows_string = get_attribute(HTML::AttributeNames::rows); rows_string.has_value()) {
if (auto rows = parse_non_negative_integer(*rows_string); rows.has_value())
return *rows;
}
return 2;
}