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 260 matching lines @@
       builder_->SetDirection(constraint_space_->Direction());
       builder_->SetWritingMode(constraint_space_->WritingMode());
       builder_->SetInlineSize(inline_size).SetBlockSize(block_size);
 
       current_child_ = first_child_;
       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
+        EPosition position = current_child_->Style()->position();
+        if ((position == AbsolutePosition || position == FixedPosition)) {
+          builder_->AddOutOfFlowChildCandidate(current_child_,
+                                               GetChildSpaceOffset());
+          current_child_ = current_child_->NextSibling();
+          return kNotFinished;
+        }
         space_for_current_child_ = CreateConstraintSpaceForCurrentChild();
         *algorithm_out = NGLayoutInputNode::AlgorithmForInputNode(
             current_child_, space_for_current_child_);
         layout_state_ = kStateChildLayout;
         return kChildAlgorithmRequired;
       }
 
-      layout_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;
+      layout_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();
       layout_state_ = kStatePrepareForChildLayout;
       return kNotFinished;
     }
+    case kStateOutOfFlowLayout:
+      if (LayoutOutOfFlowChild())
+        layout_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(
-          ConstraintSpace(), Style(), content_size_);
-
-      builder_->SetBlockSize(block_size)
-          .SetInlineOverflow(max_inline_size_)
+      builder_->SetInlineOverflow(max_inline_size_)
           .SetBlockOverflow(content_size_);
       *fragment_out = builder_->ToFragment();
       layout_state_ = kStateInit;
       return kNewFragment;
     }
   };
   NOTREACHED();
   *fragment_out = nullptr;
   return kNewFragment;
 }
 
 void NGBlockLayoutAlgorithm::FinishCurrentChildLayout(
     NGFragmentBase* fragment) {
   NGBoxStrut child_margins = ComputeMargins(
       *space_for_current_child_, CurrentChildStyle(),
       constraint_space_->WritingMode(), constraint_space_->Direction());
 
   NGLogicalOffset fragment_offset;
   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() {
+  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) == kNewFragment) {
+    // TODO(atotic) Need to adjust size of overflow rect per spec.
+    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 140 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(current_minmax_child_);
+  visitor->trace(out_of_flow_layout_);
+  visitor->trace(out_of_flow_candidates_);
 }
 
 }  // namespace blink