Place the out of flow positioned blocks

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"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_fragment.h"
 #include "core/layout/ng/ng_layout_opportunity_iterator.h"
 #include "core/layout/ng/ng_length_utils.h"
+#include "core/layout/ng/ng_out_of_flow_layout_part.h"
 #include "core/layout/ng/ng_units.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/LengthFunctions.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 namespace {
 
 // Adjusts content's offset to CSS "clear" property.
 // TODO(glebl): Support margin collapsing edge cases, e.g. margin collapsing
@@ skipping 211 matching lines @@
       builder_->SetDirection(constraint_space_->Direction());
       builder_->SetWritingMode(constraint_space_->WritingMode());
       builder_->SetInlineSize(inline_size).SetBlockSize(block_size);
 
       current_child_ = first_child_;
       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;
-        return kChildAlgorithmRequired;
+        EPosition position = current_child_->Style()->position();
+        if ((position == AbsolutePosition || position == FixedPosition)) {
+          builder_->AddOutOfFlowChildCandidate(current_child_,
+                                               GetChildSpaceOffset());
+          current_child_ = current_child_->NextSibling();
+          return kNotFinished;
+        } else {

[cbiesinger, 2016/12/21 21:38:50]

No need for an "else" after a return.

[atotic, 2016/12/28 19:36:46]

done

+          space_for_current_child_ = CreateConstraintSpaceForCurrentChild();
+          *algorithm_out = NGLayoutInputNode::AlgorithmForInputNode(
+              current_child_, space_for_current_child_);
+          state_ = kStateChildLayout;
+          return kChildAlgorithmRequired;
+        }
       }
 
-      state_ = kStateFinalize;
+      // Prepare for kStateOutOfFlowLayout
+      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);
+
+      // Out of flow setup.
+      out_of_flow_layout_ = new NGOutOfFlowLayoutPart(style_, builder_->Size());
+      builder_->GetAndClearOutOfFlowDescendantCandidates(
+          &out_of_flow_candidates_, &out_of_flow_candidate_positions_);
+      out_of_flow_candidate_positions_index_ = 0;
+      current_child_ = nullptr;
+      state_ = kStateOutOfFlowLayout;
       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;
       return kNotFinished;
     }
+    case kStateOutOfFlowLayout:
+      if (LayoutOutOfFlowChild())
+        state_ = kStateFinalize;
+      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(

[cbiesinger, 2016/12/21 21:38:50]

You don't need this anymore since you're now calling it above, right?

[atotic, 2016/12/28 19:36:45]

done. Thanks, nice catch, I blame this on persistent merge conflicts.

           ConstraintSpace(), Style(), content_size_);
 
       builder_->SetBlockSize(block_size)
           .SetInlineOverflow(max_inline_size_)
           .SetBlockOverflow(content_size_);
       *fragment_out = builder_->ToFragment();
       state_ = kStateInit;
       return kNewFragment;
     }
   };
@@ skipping 12 matching lines @@
   if (CurrentChildStyle().isFloating()) {
     fragment_offset = PositionFloatFragment(*fragment, child_margins);
   } else {
     ApplyAutoMargins(*space_for_current_child_, CurrentChildStyle(), *fragment,
                      &child_margins);
     fragment_offset = PositionFragment(*fragment, child_margins);
   }
   builder_->AddChild(fragment, fragment_offset);
 }
 
+bool NGBlockLayoutAlgorithm::LayoutOutOfFlowChild() {

[cbiesinger, 2016/12/21 21:38:50]

Maybe use NGLayoutStatus as the return type so it's not necessary to remember
whether true means finished or more work.
(Of course, kChildAlgorithmRequired would not be used here)

[atotic, 2016/12/28 19:36:45]

Unsure about this. 
Pros: not necessary to remember what true means
Cons: introducing state machine knowledge into this routine. Currently, all it
knows is how to layout oof children. Only routine that knows about layout_state_
is Layout().

What do you think about just adding documentation for the return value?

[cbiesinger, 2017/01/04 00:13:16]

Just documentation is fine with me, though it seems that this function will
implicitly know about state machines via NGOutOfFlowLayoutPart::Layout.

+  if (!current_child_) {
+    if (out_of_flow_candidates_.isEmpty()) {
+      out_of_flow_layout_ = nullptr;
+      out_of_flow_candidate_positions_.clear();
+      return true;
+    }
+    current_child_ = out_of_flow_candidates_.first();
+    out_of_flow_candidates_.removeFirst();
+    NGStaticPosition position = out_of_flow_candidate_positions_
+        [out_of_flow_candidate_positions_index_++];
+
+    if (!out_of_flow_layout_->StartLayout(current_child_, position)) {
+      builder_->AddOutOfFlowDescendant(current_child_, position);
+      current_child_ = nullptr;
+      return false;
+    }
+  }
+  NGFragmentBase* fragment;
+  NGLogicalOffset offset;
+  if (out_of_flow_layout_->Layout(&fragment, &offset)) {
+    // TODO(atotic) Do we need to adjust builder content size here?

[cbiesinger, 2016/12/21 21:38:50]

abspos does not change the width/height of the containing block, but it does
affect the overflow rect:
http://plexode.com/eval3/#s=aekVQXANJVQMbAx1yAXgePQOCGwESERFRWRwBfJ1CVlVQpIud...

But, that can be done later.

[atotic, 2016/12/28 19:36:46]

done. Added a comment.

+    builder_->AddChild(fragment, offset);
+    current_child_ = nullptr;
+  }
+  return false;
+}
+
 NGBoxStrut NGBlockLayoutAlgorithm::CollapseMargins(
     const NGBoxStrut& margins,
     const NGFragment& fragment) {
   bool is_zero_height_box = !fragment.BlockSize() && margins.IsEmpty() &&
                             fragment.MarginStrut().IsEmpty();
   // Create the current child's margin strut from its children's margin strut or
   // use margin strut from the the last non-empty child.
   NGMarginStrut curr_margin_strut =
       is_zero_height_box ? prev_child_margin_strut_ : fragment.MarginStrut();
 
@@ skipping 132 matching lines @@
 
 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(out_of_flow_layout_);
+  visitor->trace(out_of_flow_candidates_);
 }
 
 }  // namespace blink