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

third_party/WebKit/Source/core/layout/ng/ng_block_layout_algorithm.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_break_token.h"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_fragment_base.h"
@@ skipping 163 matching lines @@
 }
 
 }  // namespace
 
 NGBlockLayoutAlgorithm::NGBlockLayoutAlgorithm(
     PassRefPtr<const ComputedStyle> style,
     NGBlockNode* first_child,
     NGConstraintSpace* constraint_space,
     NGBreakToken* break_token)
     : NGLayoutAlgorithm(kBlockLayoutAlgorithm),
-      state_(kStateInit),
+      layout_state_(kStateInit),
+      compute_minmax_state_(kStateInit),
       style_(style),
       first_child_(first_child),
       constraint_space_(constraint_space),
       break_token_(break_token),
       is_fragment_margin_strut_block_start_updated_(false) {
   DCHECK(style_);
 }
 
+NGLayoutAlgorithm::MinAndMaxState
+NGBlockLayoutAlgorithm::ComputeMinAndMaxContentSizes(
+    MinAndMaxContentSizes* sizes) {
+  switch (compute_minmax_state_) {
+    case kStateInit:
+      pending_minmax_sizes_.min_content = pending_minmax_sizes_.max_content =
+          LayoutUnit();
+      // Size-contained elements don't consider their contents for intrinsic
+      // sizing.
+      if (style_->containsSize())
+        return kSuccess;
+      current_minmax_child_ = first_child_;
+      compute_minmax_state_ = kStateChildLayout;
+    case kStateChildLayout:
+      // TODO: handle floats & orthogonal children
+      if (current_minmax_child_) {
+        Optional<MinAndMaxContentSizes> child_minmax;
+        if (NeedMinAndMaxContentSizesForContentContribution(
+                *current_minmax_child_->Style())) {
+          child_minmax = MinAndMaxContentSizes();
+          if (!current_minmax_child_->ComputeMinAndMaxContentSizes(
+                  &*child_minmax))
+            return kPending;
+        }
+        MinAndMaxContentSizes child_sizes = ComputeMinAndMaxContentContribution(
+            *current_minmax_child_->Style(), child_minmax);
+        pending_minmax_sizes_.min_content = std::max(
+            pending_minmax_sizes_.min_content, child_sizes.min_content);
+        pending_minmax_sizes_.max_content = std::max(
+            pending_minmax_sizes_.max_content, child_sizes.max_content);
+
+        current_minmax_child_ = current_minmax_child_->NextSibling();
+        if (current_minmax_child_)
+          return kPending;
+      }
+
+      *sizes = pending_minmax_sizes_;
+      sizes->max_content = std::max(sizes->min_content, sizes->max_content);
+      compute_minmax_state_ = kStateInit;
+      return kSuccess;
+    default:
+      NOTREACHED();
+      return kSuccess;
+  };
+}
+
 NGLayoutStatus NGBlockLayoutAlgorithm::Layout(
     NGPhysicalFragmentBase* child_fragment,
     NGPhysicalFragmentBase** fragment_out,
     NGLayoutAlgorithm** algorithm_out) {
-  switch (state_) {
+  switch (layout_state_) {
     case kStateInit: {
+      WTF::Optional<MinAndMaxContentSizes> sizes;
+      if (NeedMinAndMaxContentSizes(ConstraintSpace(), Style())) {
+        sizes = MinAndMaxContentSizes();
+        if (ComputeMinAndMaxContentSizes(&*sizes) == kPending)
+          return kNotFinished;
+      }
+
       border_and_padding_ =
           ComputeBorders(Style()) + ComputePadding(ConstraintSpace(), Style());
 
-      WTF::Optional<MinAndMaxContentSizes> sizes;
-      if (NeedMinAndMaxContentSizes(ConstraintSpace(), Style())) {
-        // TODOO(layout-ng): Implement
-        sizes = MinAndMaxContentSizes();
-      }
       LayoutUnit inline_size =
           ComputeInlineSizeForFragment(ConstraintSpace(), Style(), sizes);
       LayoutUnit adjusted_inline_size =
           inline_size - border_and_padding_.InlineSum();
       // TODO(layout-ng): For quirks mode, should we pass blockSize instead of
       // -1?
       LayoutUnit block_size = ComputeBlockSizeForFragment(
           ConstraintSpace(), Style(), NGSizeIndefinite);
       LayoutUnit adjusted_block_size(block_size);
       // Our calculated block-axis size may be indefinite at this point.
@@ skipping 14 matching lines @@
           NGLogicalSize(adjusted_inline_size, adjusted_block_size));
 
       content_size_ = border_and_padding_.block_start;
 
       builder_ = new NGFragmentBuilder(NGPhysicalFragmentBase::kFragmentBox);
       builder_->SetDirection(constraint_space_->Direction());
       builder_->SetWritingMode(constraint_space_->WritingMode());
       builder_->SetInlineSize(inline_size).SetBlockSize(block_size);
 
       current_child_ = first_child_;
-      state_ = kStatePrepareForChildLayout;
+      layout_state_ = kStatePrepareForChildLayout;
       return kNotFinished;
     }
     case kStatePrepareForChildLayout: {
       if (current_child_) {
         // TODO(atotic): uncomment this code when implementing oof layout.
         // This code cannot be turned on because it prevents layout of
         // oof children, and non-layedout objects trigger  a DCHECK.
         // EPosition position = current_child_->Style()->position();
         // if ((position == AbsolutePosition || position == FixedPosition)) {
         //   builder_->AddOutOfFlowCandidateChild(current_child_,
         //   GetChildSpaceOffset());
         // }
         // else
         space_for_current_child_ = CreateConstraintSpaceForCurrentChild();
         *algorithm_out = NGLayoutInputNode::AlgorithmForInputNode(
             current_child_, space_for_current_child_);
-        state_ = kStateChildLayout;
+        layout_state_ = kStateChildLayout;
         return kChildAlgorithmRequired;
       }
 
-      state_ = kStateFinalize;
+      layout_state_ = kStateFinalize;
       return kNotFinished;
     }
     case kStateChildLayout: {
       DCHECK(current_child_);
       DCHECK(child_fragment);
 
       // TODO(layout_ng): Seems like a giant hack to call this here.
       current_child_->UpdateLayoutBox(toNGPhysicalFragment(child_fragment),
                                       space_for_current_child_);
 
       FinishCurrentChildLayout(new NGFragment(
           ConstraintSpace().WritingMode(), ConstraintSpace().Direction(),
           toNGPhysicalFragment(child_fragment)));
       current_child_ = current_child_->NextSibling();
-      state_ = kStatePrepareForChildLayout;
+      layout_state_ = kStatePrepareForChildLayout;
       return kNotFinished;
     }
     case kStateFinalize: {
       content_size_ += border_and_padding_.block_end;
 
       // Recompute the block-axis size now that we know our content size.
       LayoutUnit block_size = ComputeBlockSizeForFragment(
           ConstraintSpace(), Style(), content_size_);
 
       builder_->SetBlockSize(block_size)
           .SetInlineOverflow(max_inline_size_)
           .SetBlockOverflow(content_size_);
       *fragment_out = builder_->ToFragment();
-      state_ = kStateInit;
+      layout_state_ = kStateInit;
       return kNewFragment;
     }
   };
   NOTREACHED();
   *fragment_out = nullptr;
   return kNewFragment;
 }
 
 void NGBlockLayoutAlgorithm::FinishCurrentChildLayout(
     NGFragmentBase* fragment) {
@@ skipping 137 matching lines @@
   }
   builder_->SetMarginStrutBlockEnd(from);
 }
 
 NGConstraintSpace*
 NGBlockLayoutAlgorithm::CreateConstraintSpaceForCurrentChild() const {
   // TODO(layout-ng): Orthogonal children should also shrink to fit (in *their*
   // inline axis)
   // We have to keep this commented out for now until we correctly compute
   // min/max content sizes in Layout().
-  // bool shrink_to_fit = CurrentChildStyle().display() == EDisplay::InlineBlock
-  // || CurrentChildStyle().isFloating();
-  bool shrink_to_fit = false;
+  bool shrink_to_fit = CurrentChildStyle().display() == EDisplay::InlineBlock ||
+                       CurrentChildStyle().isFloating();
   DCHECK(current_child_);
   space_builder_
       ->SetIsNewFormattingContext(
           IsNewFormattingContextForInFlowBlockLevelChild(ConstraintSpace(),
                                                          CurrentChildStyle()))
       .SetIsShrinkToFit(shrink_to_fit)
       .SetWritingMode(
           FromPlatformWritingMode(CurrentChildStyle().getWritingMode()))
       .SetTextDirection(CurrentChildStyle().direction());
   NGConstraintSpace* child_space = space_builder_->ToConstraintSpace();
 
   // TODO(layout-ng): Set offset through the space builder.
   child_space->SetOffset(GetChildSpaceOffset());
   return child_space;
 }
 
 DEFINE_TRACE(NGBlockLayoutAlgorithm) {
   NGLayoutAlgorithm::trace(visitor);
   visitor->trace(first_child_);
   visitor->trace(constraint_space_);
   visitor->trace(break_token_);
   visitor->trace(builder_);
   visitor->trace(space_builder_);
   visitor->trace(space_for_current_child_);
   visitor->trace(current_child_);
+  visitor->trace(current_minmax_child_);
 }
 
 }  // namespace blink