[LayoutNG] Implement ComputeMinAndMaxContentSizes for inline

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_absolute_utils.h"
 #include "core/layout/ng/ng_block_break_token.h"
 #include "core/layout/ng/ng_box_fragment.h"
 #include "core/layout/ng/ng_column_mapper.h"
@@ skipping 299 matching lines @@
 NGBlockLayoutAlgorithm::ComputeMinAndMaxContentSizes() const {
   MinAndMaxContentSizes sizes;
 
   // Size-contained elements don't consider their contents for intrinsic sizing.
   if (Style().containsSize())
     return sizes;
 
   // TODO: handle floats & orthogonal children.
   for (NGLayoutInputNode* node = node_->FirstChild(); node;
        node = node->NextSibling()) {
-    Optional<MinAndMaxContentSizes> child_minmax;
+    MinAndMaxContentSizes child_sizes;
     if (node->Type() == NGLayoutInputNode::kLegacyInline) {
-      // TODO(kojii): Implement when there are inline children.
-      return child_minmax;
+      // From |NGBlockLayoutAlgorithm| perspective, we can handle |NGInlineNode|
+      // almost the same as |NGBlockNode|, because an |NGInlineNode| includes
+      // all inline nodes following |node| and their descendants, and produces
+      // an anonymous box that contains all line boxes.
+      // |NextSibling| returns the next block sibling, or nullptr, skipping all
+      // following inline siblings and descendants.
+      child_sizes = toNGInlineNode(node)->ComputeMinAndMaxContentSizes();
+    } else {
+      Optional<MinAndMaxContentSizes> child_minmax;
+      NGBlockNode* block_child = toNGBlockNode(node);
+      if (NeedMinAndMaxContentSizesForContentContribution(
+              block_child->Style())) {
+        child_minmax = block_child->ComputeMinAndMaxContentSizes();
+      }
+
+      child_sizes = ComputeMinAndMaxContentContribution(block_child->Style(),
+                                                        child_minmax);
     }
-    NGBlockNode* block_child = toNGBlockNode(node);
-    if (NeedMinAndMaxContentSizesForContentContribution(block_child->Style())) {
-      child_minmax = block_child->ComputeMinAndMaxContentSizes();
-    }
-
-    MinAndMaxContentSizes child_sizes =
-        ComputeMinAndMaxContentContribution(block_child->Style(), child_minmax);
 
     sizes.min_content = std::max(sizes.min_content, child_sizes.min_content);
     sizes.max_content = std::max(sizes.max_content, child_sizes.max_content);
   }
 
   sizes.max_content = std::max(sizes.min_content, sizes.max_content);
   return sizes;
 }
 
 NGLogicalOffset NGBlockLayoutAlgorithm::CalculateLogicalOffset(
@@ skipping 169 matching lines @@
     FinalizeForFragmentation();
 
   return builder_->ToBoxFragment();
 }
 
 void NGBlockLayoutAlgorithm::LayoutInlineChildren(NGInlineNode* current_child) {
   // TODO(kojii): This logic does not handle when children are mix of
   // inline/block. We need to detect the case and setup appropriately; e.g.,
   // constraint space, margin collapsing, next siblings, etc.
   NGLineBuilder line_builder(current_child, space_for_current_child_);
+  // TODO(kojii): Need to determine when to invalidate PrepareLayout() more
+  // efficiently than "everytime".
+  current_child->InvalidatePrepareLayout();
   current_child->LayoutInline(space_for_current_child_, &line_builder);
   // TODO(kojii): The wrapper fragment should not be needed.
   NGFragmentBuilder wrapper_fragment_builder(NGPhysicalFragment::kFragmentBox,
                                              current_child);
   line_builder.CreateFragments(&wrapper_fragment_builder);
   RefPtr<NGLayoutResult> child_result =
       wrapper_fragment_builder.ToBoxFragment();
   line_builder.CopyFragmentDataToLayoutBlockFlow();
   FinishCurrentChildLayout(child_result);
   current_child_ = nullptr;
@@ skipping 309 matching lines @@
     curr_margin_strut_.Append(curr_child_margins_.block_start);
     space_builder_->SetMarginStrut(curr_margin_strut_);
   }
 
   space_builder_->SetBfcOffset(curr_bfc_offset_);
 
   return space_builder_->ToConstraintSpace(
       FromPlatformWritingMode(current_child_style.getWritingMode()));
 }
 }  // namespace blink