[LayoutNG] Don't use Optional<> for clearance offset.

The exclusion space already didn't use it, but rather returned a pure
LayoutUnit set to LayoutUnit::Min() if there was no clearance to apply.
Do this everywhere, instead of using Optional<LayoutUnit> some places.

Better have one way of saying "no clearance", than two
(Optional<LayoutUnit> not set OR Optional<LayoutUnit> set to

LayoutUnit: :Min()).
Cq-Include-Trybots: master.tryserver.chromium.linux:linux_layout_tests_layout_ng
Change-Id: I3a858397c28ca83ba96ae4d749f97dfa5e7b0cb3
Reviewed-on: https://chromium-review.googlesource.com/1027810Reviewed-by: Ian Kilpatrick <ikilpatrick@chromium.org>
Commit-Queue: Morten Stenshorne <mstensho@chromium.org>
Cr-Commit-Position: refs/heads/master@{#553722}

third_party/blink/renderer/core/layout/ng/ng_block_layout_algorithm.cc

@@ -424,16 +424,15 @@ scoped_refptr<NGLayoutResult> NGBlockLayoutAlgorithm::Layout() {
     // We can use the BFC coordinates, as we are a new formatting context.
     DCHECK_EQ(container_builder_.BfcOffset().value(), NGBfcOffset());
 
-    base::Optional<LayoutUnit> float_end_offset =
+    LayoutUnit float_end_offset =
         exclusion_space_->ClearanceOffset(EClear::kBoth);
 
     // We only update the size of this fragment if we need to grow to
     // encapsulate the floats.
-    if (float_end_offset && float_end_offset.value() > end_bfc_block_offset) {
+    if (float_end_offset > end_bfc_block_offset) {
       end_margin_strut = NGMarginStrut();
-      end_bfc_block_offset = float_end_offset.value();
-      intrinsic_block_size_ =
-          std::max(intrinsic_block_size_, float_end_offset.value());
+      end_bfc_block_offset = float_end_offset;
+      intrinsic_block_size_ = std::max(intrinsic_block_size_, float_end_offset);
     }
   }
 
@@ -872,9 +871,7 @@ bool NGBlockLayoutAlgorithm::HandleInflow(
     // If our BFC offset was updated we may have been affected by clearance
     // ourselves. We need to adjust the origin point to accomodate this.
     if (updated)
-      origin_point_block_offset =
-          std::max(origin_point_block_offset,
-                   ConstraintSpace().ClearanceOffset().value_or(LayoutUnit()));
+      origin_point_block_offset = container_builder_.BfcOffset()->block_offset;
 
     bool positioned_direct_child_floats = !unpositioned_floats_.IsEmpty();
 
@@ -1602,21 +1599,16 @@ NGBlockLayoutAlgorithm::CreateConstraintSpaceForChild(
   }
 
   WritingMode writing_mode;
-  base::Optional<LayoutUnit> clearance_offset;
-  if (!constraint_space_.IsNewFormattingContext())
-    clearance_offset = ConstraintSpace().ClearanceOffset();
+  LayoutUnit clearance_offset = constraint_space_.IsNewFormattingContext()
+                                    ? LayoutUnit::Min()
+                                    : ConstraintSpace().ClearanceOffset();
   if (child.IsInline()) {
     writing_mode = Style().GetWritingMode();
   } else {
     const ComputedStyle& child_style = child.Style();
     LayoutUnit child_clearance_offset =
         exclusion_space_->ClearanceOffset(child_style.Clear());
-    if (clearance_offset) {
-      clearance_offset =
-          std::max(clearance_offset.value(), child_clearance_offset);
-    } else {
-      clearance_offset = child_clearance_offset;
-    }
+    clearance_offset = std::max(clearance_offset, child_clearance_offset);
     space_builder.SetIsShrinkToFit(ShouldShrinkToFit(Style(), child_style));
     space_builder.SetTextDirection(child_style.Direction());
     writing_mode = child_style.GetWritingMode();

third_party/blink/renderer/core/layout/ng/ng_constraint_space.cc

@@ -52,7 +52,7 @@ NGConstraintSpace::NGConstraintSpace(
     const base::Optional<NGBfcOffset>& floats_bfc_offset,
     const NGExclusionSpace& exclusion_space,
     Vector<scoped_refptr<NGUnpositionedFloat>>& unpositioned_floats,
-    const base::Optional<LayoutUnit>& clearance_offset,
+    LayoutUnit clearance_offset,
     Vector<NGBaselineRequest>& baseline_requests)
     : available_size_(available_size),
       percentage_resolution_size_(percentage_resolution_size),
@@ -259,15 +259,14 @@ bool NGConstraintSpace::operator!=(const NGConstraintSpace& other) const {
 }
 
 String NGConstraintSpace::ToString() const {
-  return String::Format(
-      "Offset: %s,%s Size: %sx%s Clearance: %s",
-      bfc_offset_.line_offset.ToString().Ascii().data(),
-      bfc_offset_.block_offset.ToString().Ascii().data(),
-      AvailableSize().inline_size.ToString().Ascii().data(),
-      AvailableSize().block_size.ToString().Ascii().data(),
-      clearance_offset_.has_value()
-          ? clearance_offset_.value().ToString().Ascii().data()
-          : "none");
+  return String::Format("Offset: %s,%s Size: %sx%s Clearance: %s",
+                        bfc_offset_.line_offset.ToString().Ascii().data(),
+                        bfc_offset_.block_offset.ToString().Ascii().data(),
+                        AvailableSize().inline_size.ToString().Ascii().data(),
+                        AvailableSize().block_size.ToString().Ascii().data(),
+                        HasClearanceOffset()
+                            ? ClearanceOffset().ToString().Ascii().data()
+                            : "none");
 }
 
 }  // namespace blink

third_party/blink/renderer/core/layout/ng/ng_constraint_space.h

@@ -189,9 +189,10 @@ class CORE_EXPORT NGConstraintSpace final
     return unpositioned_floats_;
   }
 
-  base::Optional<LayoutUnit> ClearanceOffset() const {
-    return clearance_offset_;
+  bool HasClearanceOffset() const {
+    return clearance_offset_ != LayoutUnit::Min();
   }
+  LayoutUnit ClearanceOffset() const { return clearance_offset_; }
 
   const Vector<NGBaselineRequest>& BaselineRequests() const {
     return baseline_requests_;
@@ -230,7 +231,7 @@ class CORE_EXPORT NGConstraintSpace final
       const base::Optional<NGBfcOffset>& floats_bfc_offset,
       const NGExclusionSpace& exclusion_space,
       Vector<scoped_refptr<NGUnpositionedFloat>>& unpositioned_floats,
-      const base::Optional<LayoutUnit>& clearance_offset,
+      LayoutUnit clearance_offset,
       Vector<NGBaselineRequest>& baseline_requests);
 
   NGLogicalSize available_size_;
@@ -268,7 +269,7 @@ class CORE_EXPORT NGConstraintSpace final
   base::Optional<NGBfcOffset> floats_bfc_offset_;
 
   const std::unique_ptr<const NGExclusionSpace> exclusion_space_;
-  base::Optional<LayoutUnit> clearance_offset_;
+  LayoutUnit clearance_offset_;
   Vector<scoped_refptr<NGUnpositionedFloat>> unpositioned_floats_;
 
   Vector<NGBaselineRequest> baseline_requests_;

third_party/blink/renderer/core/layout/ng/ng_constraint_space_builder.cc

@@ -71,7 +71,7 @@ NGConstraintSpaceBuilder& NGConstraintSpaceBuilder::SetFloatsBfcOffset(
 }
 
 NGConstraintSpaceBuilder& NGConstraintSpaceBuilder::SetClearanceOffset(
-    const base::Optional<LayoutUnit>& clearance_offset) {
+    LayoutUnit clearance_offset) {
   clearance_offset_ = clearance_offset;
   return *this;
 }
@@ -211,8 +211,8 @@ scoped_refptr<NGConstraintSpace> NGConstraintSpaceBuilder::ToConstraintSpace(
                                                 : *exclusion_space_;
   NGBfcOffset bfc_offset = is_new_fc_ ? NGBfcOffset() : bfc_offset_;
   NGMarginStrut margin_strut = is_new_fc_ ? NGMarginStrut() : margin_strut_;
-  base::Optional<LayoutUnit> clearance_offset =
-      is_new_fc_ ? base::nullopt : clearance_offset_;
+  LayoutUnit clearance_offset =
+      is_new_fc_ ? LayoutUnit::Min() : clearance_offset_;
   base::Optional<NGBfcOffset> floats_bfc_offset =
       is_new_fc_ ? base::nullopt : floats_bfc_offset_;
 

third_party/blink/renderer/core/layout/ng/ng_constraint_space_builder.h

@@ -72,8 +72,7 @@ class CORE_EXPORT NGConstraintSpaceBuilder final {
   NGConstraintSpaceBuilder& SetFloatsBfcOffset(
       const base::Optional<NGBfcOffset>& floats_bfc_offset);
 
-  NGConstraintSpaceBuilder& SetClearanceOffset(
-      const base::Optional<LayoutUnit>& clearance_offset);
+  NGConstraintSpaceBuilder& SetClearanceOffset(LayoutUnit clearance_offset);
 
   NGConstraintSpaceBuilder& SetExclusionSpace(
       const NGExclusionSpace& exclusion_space);
@@ -118,7 +117,7 @@ class CORE_EXPORT NGConstraintSpaceBuilder final {
   NGBfcOffset bfc_offset_;
   base::Optional<NGBfcOffset> floats_bfc_offset_;
   const NGExclusionSpace* exclusion_space_;
-  base::Optional<LayoutUnit> clearance_offset_;
+  LayoutUnit clearance_offset_;
   Vector<scoped_refptr<NGUnpositionedFloat>> unpositioned_floats_;
   Vector<NGBaselineRequest> baseline_requests_;
 };

third_party/blink/renderer/core/layout/ng/ng_floats_utils.cc

@@ -37,7 +37,7 @@ NGLayoutOpportunity FindLayoutOpportunityForFloat(
     LayoutUnit inline_size) {
   NGBfcOffset adjusted_origin_point =
       AdjustToTopEdgeAlignmentRule(exclusion_space, origin_offset);
-  base::Optional<LayoutUnit> clearance_offset =
+  LayoutUnit clearance_offset =
       exclusion_space.ClearanceOffset(unpositioned_float.ClearType());
 
   AdjustToClearance(clearance_offset, &adjusted_origin_point);

third_party/blink/renderer/core/layout/ng/ng_space_utils.cc

@@ -21,11 +21,10 @@ bool ShouldShrinkToFit(const ComputedStyle& parent_style,
          !is_in_parallel_flow;
 }
 
-bool AdjustToClearance(const base::Optional<LayoutUnit>& clearance_offset,
-                       NGBfcOffset* offset) {
+bool AdjustToClearance(LayoutUnit clearance_offset, NGBfcOffset* offset) {
   DCHECK(offset);
-  if (clearance_offset && clearance_offset.value() > offset->block_offset) {
-    offset->block_offset = clearance_offset.value();
+  if (clearance_offset > offset->block_offset) {
+    offset->block_offset = clearance_offset;
     return true;
   }
 

third_party/blink/renderer/core/layout/ng/ng_space_utils.h

@@ -21,9 +21,8 @@ bool ShouldShrinkToFit(const ComputedStyle& parent_style,
                        const ComputedStyle& style);
 
 // Adjusts {@code offset} to the clearance line.
-CORE_EXPORT bool AdjustToClearance(
-    const base::Optional<LayoutUnit>& clearance_offset,
-    NGBfcOffset* offset);
+CORE_EXPORT bool AdjustToClearance(LayoutUnit clearance_offset,
+                                   NGBfcOffset* offset);
 
 }  // namespace blink