Reset constraint space's BFC offset if block creates a new FC

third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm_test.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/layout/ng/ng_block_layout_algorithm.h"
 
 #include "core/dom/NodeComputedStyle.h"
 #include "core/dom/TagCollection.h"
 #include "core/layout/LayoutTestHelper.h"
 #include "core/layout/ng/layout_ng_block_flow.h"
@@ skipping 336 matching lines @@
   // second child's height(50)
   int empty5_fragment_block_offset = 90;
   EXPECT_THAT(LayoutUnit(empty5_fragment_block_offset),
               empty5_fragment->TopOffset());
 
   ASSERT_EQ(1UL, body_fragment->PositionedFloats().size());
   ASSERT_EQ(1UL, body_fragment->PositionedFloats().size());
   auto float_nonempties_fragment =
       body_fragment->PositionedFloats().at(0)->fragment;
   // 70 = first_child's height(50) + first child's margin-bottom(20)
-  EXPECT_THAT(LayoutUnit(70), float_nonempties_fragment->TopOffset());
-  EXPECT_THAT(LayoutUnit(0), float_nonempties_fragment->LeftOffset());
+  EXPECT_THAT(float_nonempties_fragment->TopOffset(), LayoutUnit(70));
+  EXPECT_THAT(float_nonempties_fragment->LeftOffset(), LayoutUnit(0));
 
   // ** Verify layout tree **
   Element* first_child = document().getElementById("first-child");
   // -7 = body_top_offset
   EXPECT_EQ(body_top_offset, first_child->offsetTop());
 }
 
 // Verifies the collapsing margins case for the next pair:
 // - bottom margin of a last in-flow child and bottom margin of its parent if
 //   the parent has 'auto' computed height
@@ skipping 473 matching lines @@
 
   // ** Run LayoutNG algorithm **
   RefPtr<NGConstraintSpace> space;
   RefPtr<NGPhysicalBoxFragment> fragment;
   std::tie(fragment, space) = RunBlockLayoutAlgorithmForElement(
       document().getElementsByTagName("html")->item(0));
 
   auto* body_fragment = toNGPhysicalBoxFragment(fragment->Children()[0].get());
   // 20 = std::max(empty1's margin, empty2's margin, body's margin)
   int body_top_offset = 20;
-  EXPECT_THAT(LayoutUnit(body_top_offset), body_fragment->TopOffset());
+  EXPECT_THAT(body_fragment->TopOffset(), LayoutUnit(body_top_offset));
   ASSERT_EQ(1UL, body_fragment->Children().size());
   auto* container_fragment =
       toNGPhysicalBoxFragment(body_fragment->Children()[0].get());
   ASSERT_EQ(1UL, container_fragment->Children().size());
 
   auto* empty1_fragment =
       toNGPhysicalBoxFragment(container_fragment->Children()[0].get());
   // 0, vertical margins got collapsed
-  EXPECT_THAT(LayoutUnit(), empty1_fragment->TopOffset());
+  EXPECT_THAT(empty1_fragment->TopOffset(), LayoutUnit());
   // 20 empty1's margin
   int empty1_inline_offset = 20;
-  EXPECT_THAT(LayoutUnit(empty1_inline_offset), empty1_fragment->LeftOffset());
+  EXPECT_THAT(empty1_fragment->LeftOffset(), LayoutUnit(empty1_inline_offset));
   ASSERT_EQ(empty1_fragment->Children().size(), 1UL);
 
   auto* empty2_fragment =
       toNGPhysicalBoxFragment(empty1_fragment->Children()[0].get());
   // 0, vertical margins got collapsed
   EXPECT_THAT(LayoutUnit(), empty2_fragment->TopOffset());
   // 35 = empty1's padding(20) + empty2's padding(15)
   int empty2_inline_offset = 35;
-  EXPECT_THAT(LayoutUnit(empty2_inline_offset), empty2_fragment->LeftOffset());
+  EXPECT_THAT(empty2_fragment->LeftOffset(), LayoutUnit(empty2_inline_offset));
 
   ASSERT_EQ(2UL, container_fragment->PositionedFloats().size());
   RefPtr<NGPhysicalFragment> left_float_fragment =
       container_fragment->PositionedFloats().at(0)->fragment;
   // inline 25 = empty2's padding(15) + left float's margin(10)
   // block 10 = left float's margin
-  EXPECT_THAT(NGPhysicalOffset(LayoutUnit(25), LayoutUnit(10)),
-              left_float_fragment->Offset());
+  EXPECT_THAT(left_float_fragment->Offset(),
+              NGPhysicalOffset(LayoutUnit(25), LayoutUnit(10)));
 
   auto right_float_fragment =
       container_fragment->PositionedFloats().at(1)->fragment;
   LayoutUnit right_float_offset = LayoutUnit(125);
   // inline offset 150 = empty2's padding(15) + right float's margin(10) + right
   // float offset(125)
   // block offset 15 = right float's margin
   EXPECT_THAT(
-      NGPhysicalOffset(LayoutUnit(25) + right_float_offset, LayoutUnit(15)),
-      right_float_fragment->Offset());
+      right_float_fragment->Offset(),
+      NGPhysicalOffset(LayoutUnit(25) + right_float_offset, LayoutUnit(15)));
 
   // ** Verify layout tree **
   Element* left_float = document().getElementById("left-float");
   // 88 = body's margin(8) +
   // empty1's padding and margin + empty2's padding and margins + float's
   // padding
   EXPECT_THAT(left_float->offsetLeft(), 88);
   // 30 = body_top_offset(collapsed margins result) + float's padding
-  EXPECT_THAT(body_top_offset + 10, left_float->offsetTop());
+  EXPECT_THAT(left_float->offsetTop(), body_top_offset + 10);
 
   // ** Legacy Floating objects **
   // #container is the 1st non-empty block so floats are attached to it.
   Element* container = document().getElementById("container");
   auto& floating_objects =
       const_cast<FloatingObjects*>(
           toLayoutBlockFlow(container->layoutObject())->floatingObjects())
           ->mutableSet();
   ASSERT_EQ(2UL, floating_objects.size());
   auto left_floating_object = floating_objects.takeFirst();
   ASSERT_TRUE(left_floating_object->isPlaced());
   // 80 = float_inline_offset(25) + accumulative offset of empty blocks(35 + 20)
-  EXPECT_THAT(LayoutUnit(80), left_floating_object->x());
+  EXPECT_THAT(left_floating_object->x(), LayoutUnit(80));
   // 10 = left float's margin
-  EXPECT_THAT(LayoutUnit(10), left_floating_object->y());
+  EXPECT_THAT(left_floating_object->y(), LayoutUnit(10));
 
   auto right_floating_object = floating_objects.takeFirst();
   ASSERT_TRUE(right_floating_object->isPlaced());
   // 205 = float_inline_offset(25) +
   //       accumulative offset of empty blocks(35 + 20)
   //       + right float offset(125)
-  EXPECT_THAT(LayoutUnit(80) + right_float_offset, right_floating_object->x());
+  EXPECT_THAT(right_floating_object->x(), LayoutUnit(80) + right_float_offset);
   // 15 = right float's margin
-  EXPECT_THAT(LayoutUnit(15), right_floating_object->y());
+  EXPECT_THAT(right_floating_object->y(), LayoutUnit(15));
 }
 
 // Verifies that left/right floating and regular blocks can be positioned
 // correctly by the algorithm.
 TEST_F(NGBlockLayoutAlgorithmTest, PositionFloatFragments) {
   setBodyInnerHTML(R"HTML(
       <style>
         #container {
           height: 200px;
           width: 200px;
@@ skipping 1330 matching lines @@
 
   child = iterator.NextChild();
   EXPECT_EQ(NGPhysicalSize(LayoutUnit(150), LayoutUnit(100)), child->Size());
   EXPECT_EQ(NGPhysicalOffset(LayoutUnit(0), LayoutUnit(40)), child->Offset());
 
   EXPECT_FALSE(iterator.NextChild());
 }
 
 }  // namespace
 }  // namespace blink