[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 305 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;
+      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);

[cbiesinger, 2017/02/23 19:07:01]

This assumes you can linebreak between two inlines, which may not be the case

[kojii, 2017/02/24 01:55:49]

At this point, |child_sizes| contains values from all lines produced from the
all inline nodes starting |node|.

If |node| is inline, it represents a sequence of inline nodes up until the end
or it sees a block node. So in this loop, |node| is like an anonymous block that
contains all inlines starting from the |node|, and |NextSibling| returns the
next of the anonymous. The floats/OOF doc explains this a bit. Sorry for the
lack of explanation, I'll add comment.

     sizes.max_content = std::max(sizes.max_content, child_sizes.max_content);

[cbiesinger, 2017/02/23 19:07:01]

This is not correct for inline. For inline, you basically need to sum up the
sizes of all inlines within a potential row. This is actually fairly
complicated, see the old implementation:
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/layout/La...

It seems like maybe some of your NGInlineNode code needs to move here in some
way...?

[kojii, 2017/02/24 01:55:49]

Yeah, the code in |NGInlineNode::ComputeMinAndMaxContentSizes| does basically
the same thing as |LayoutBlockFlow::computeInlinePreferredLogicalWidths|.
|LayoutBlockFlow| optimizes for min/max content by not using the
|BreakingContext|, but still uses |LazyLineBreakIterator|.

Having two line breakers have been a bit of head ache for me and Emil, so we may
optimize when things are stabilized, but I'd like to use the line breaker
(NGLineBuilder) for now. There's a plan to completely replace the current line
breaker, so I don't want to create two separate paths at least until the replace
is completed.

   }
 
   sizes.max_content = std::max(sizes.min_content, sizes.max_content);
   return sizes;
 }
 
 NGLogicalOffset NGBlockLayoutAlgorithm::CalculateLogicalOffset(
     const WTF::Optional<NGLogicalOffset>& known_fragment_offset) {
   LayoutUnit inline_offset =
       border_and_padding_.inline_start + curr_child_margins_.inline_start;
@@ skipping 154 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 311 matching lines @@
     space_builder_->SetMarginStrut(curr_margin_strut_);
   }
 
   space_builder_->SetBfcOffset(curr_bfc_offset_);
 
   return space_builder_->ToConstraintSpace(
       FromPlatformWritingMode(current_child_style.getWritingMode()));
 }
 
 }  // namespace blink