[layoutng] Implement support for width: {min,max,fit}-content

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/layout/ng/ng_block_node.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_physical_fragment_base.h"
 #include "core/layout/ng/ng_physical_fragment.h"
 #include "core/layout/ng/ng_layout_coordinator.h"
 #include "core/layout/ng/ng_length_utils.h"
 #include "core/layout/ng/ng_units.h"
 #include "core/style/ComputedStyle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 namespace {
 
 NGConstraintSpace* ConstructConstraintSpace(NGWritingMode writing_mode,
                                             TextDirection direction,
-                                            NGLogicalSize size) {
+                                            NGLogicalSize size,
+                                            bool shrink_to_fit = false) {
   return NGConstraintSpaceBuilder(writing_mode)
       .SetAvailableSize(size)
       .SetPercentageResolutionSize(size)
       .SetTextDirection(direction)
       .SetWritingMode(writing_mode)
+      .SetIsShrinkToFit(shrink_to_fit)
       .ToConstraintSpace();
 }
 
 class NGBlockLayoutAlgorithmTest : public ::testing::Test {
  protected:
   void SetUp() override { style_ = ComputedStyle::create(); }
 
   NGPhysicalFragment* RunBlockLayoutAlgorithm(NGConstraintSpace* space,
                                               NGBlockNode* first_child) {
     NGBlockNode parent(style_.get());
     parent.SetFirstChild(first_child);
 
     NGLayoutCoordinator coordinator(&parent, space);
     NGPhysicalFragmentBase* fragment;
     coordinator.Tick(&fragment);
     EXPECT_EQ(kBlockLayoutAlgorithm,
               coordinator.GetAlgorithmStackForTesting()[0]->algorithmType());
     while (!coordinator.Tick(&fragment))
       ;
 
     return toNGPhysicalFragment(fragment);
   }
 
+  MinAndMaxContentSizes RunComputeMinAndMax(NGBlockNode* first_child) {
+    // The constraint space is not used for min/max computation, but we need
+    // it to create the algorithm.
+    NGConstraintSpace* space =
+        ConstructConstraintSpace(kHorizontalTopBottom, TextDirection::Ltr,
+                                 NGLogicalSize(LayoutUnit(), LayoutUnit()));
+    NGBlockLayoutAlgorithm algorithm(style_.get(), first_child, space);
+    MinAndMaxContentSizes sizes;
+    NGLayoutAlgorithm::MinAndMaxState state;
+    while ((state = algorithm.ComputeMinAndMaxContentSizes(&sizes)) !=
+           NGLayoutAlgorithm::kSuccess) {
+      EXPECT_NE(NGLayoutAlgorithm::kNotImplemented, state);
+      // shouldn't happen but let's avoid an infinite loop
+      if (state == NGLayoutAlgorithm::kNotImplemented)
+        break;
+    }
+    return sizes;
+  }
+
   RefPtr<ComputedStyle> style_;
 };
 
 TEST_F(NGBlockLayoutAlgorithmTest, FixedSize) {
   style_->setWidth(Length(30, Fixed));
   style_->setHeight(Length(40, Fixed));
 
   auto* space = ConstructConstraintSpace(
       kHorizontalTopBottom, TextDirection::Ltr,
       NGLogicalSize(LayoutUnit(100), NGSizeIndefinite));
@@ skipping 710 matching lines @@
       kHorizontalTopBottom, TextDirection::Ltr,
       NGLogicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
   frag = RunBlockLayoutAlgorithm(space, div1);
   space = ConstructConstraintSpace(
       kHorizontalTopBottom, TextDirection::Ltr,
       NGLogicalSize(LayoutUnit(kParentSize), LayoutUnit(kParentSize)));
   child3 = frag->Children()[2];
   EXPECT_EQ(kDiv1Size + kDiv2Size, child3->TopOffset());
 }
 
+// Verifies that we compute the right min and max-content size.
+TEST_F(NGBlockLayoutAlgorithmTest, ComputeMinMaxContent) {
+  const int kWidth = 50;
+  const int kWidthChild1 = 20;
+  const int kWidthChild2 = 30;
+
+  // This should have no impact on the min/max content size.
+  style_->setWidth(Length(kWidth, Fixed));
+
+  RefPtr<ComputedStyle> first_style = ComputedStyle::create();
+  first_style->setWidth(Length(kWidthChild1, Fixed));
+  NGBlockNode* first_child = new NGBlockNode(first_style.get());
+
+  RefPtr<ComputedStyle> second_style = ComputedStyle::create();
+  second_style->setWidth(Length(kWidthChild2, Fixed));
+  NGBlockNode* second_child = new NGBlockNode(second_style.get());
+
+  first_child->SetNextSibling(second_child);
+
+  MinAndMaxContentSizes sizes = RunComputeMinAndMax(first_child);
+  EXPECT_EQ(kWidthChild2, sizes.min_content);
+  EXPECT_EQ(kWidthChild2, sizes.max_content);
+}
+
+// Tests that we correctly handle shrink-to-fit
+TEST_F(NGBlockLayoutAlgorithmTest, ShrinkToFit) {
+  const int kWidthChild1 = 20;
+  const int kWidthChild2 = 30;
+
+  RefPtr<ComputedStyle> first_style = ComputedStyle::create();
+  first_style->setWidth(Length(kWidthChild1, Fixed));
+  NGBlockNode* first_child = new NGBlockNode(first_style.get());
+
+  RefPtr<ComputedStyle> second_style = ComputedStyle::create();
+  second_style->setWidth(Length(kWidthChild2, Fixed));
+  NGBlockNode* second_child = new NGBlockNode(second_style.get());
+
+  first_child->SetNextSibling(second_child);
+
+  auto* space = ConstructConstraintSpace(
+      kHorizontalTopBottom, TextDirection::Ltr,
+      NGLogicalSize(LayoutUnit(100), NGSizeIndefinite), true);
+  NGPhysicalFragmentBase* frag = RunBlockLayoutAlgorithm(space, first_child);
+
+  EXPECT_EQ(LayoutUnit(30), frag->Width());
+}
+
 }  // namespace
 }  // namespace blink