Fix calculation of abspos style properties: left/padding/width/height...

third_party/WebKit/Source/core/layout/ng/ng_out_of_flow_layout_part.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_out_of_flow_layout_part.h"
 
 #include "core/layout/ng/ng_absolute_utils.h"
 #include "core/layout/ng/ng_block_node.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_length_utils.h"
+#include "core/layout/ng/ng_physical_fragment.h"
 #include "core/style/ComputedStyle.h"
 #include "core/layout/ng/ng_fragment.h"
 
 namespace blink {
 
 NGOutOfFlowLayoutPart::NGOutOfFlowLayoutPart(
     PassRefPtr<const ComputedStyle> container_style,
     NGLogicalSize container_size) {
   contains_fixed_ = container_style->canContainFixedPositionObjects();
   contains_absolute_ =
       container_style->canContainAbsolutePositionObjects() || contains_fixed_;
   // Initialize ConstraintSpace
   NGLogicalSize space_size = container_size;
   NGBoxStrut borders = ComputeBorders(*container_style);
   space_size.block_size -= borders.BlockSum();
   space_size.inline_size -= borders.InlineSum();
   parent_offset_ = NGLogicalOffset{borders.inline_start, borders.block_start};
   parent_physical_offset_ = parent_offset_.ConvertToPhysical(
       FromPlatformWritingMode(container_style->getWritingMode()),
       container_style->direction(),
       container_size.ConvertToPhysical(
           FromPlatformWritingMode(container_style->getWritingMode())),
       NGPhysicalSize());
   NGConstraintSpaceBuilder space_builder(
       FromPlatformWritingMode(container_style->getWritingMode()));
   space_builder.SetAvailableSize(space_size);
+  space_builder.SetPercentageResolutionSize(space_size);
   space_builder.SetIsNewFormattingContext(true);
   space_builder.SetTextDirection(container_style->direction());
   parent_space_ = space_builder.ToConstraintSpace();
 }
 
 bool NGOutOfFlowLayoutPart::StartLayout(
     NGBlockNode* node,
     const NGStaticPosition& static_position) {
   EPosition position = node->Style()->position();
   if ((contains_absolute_ && position == AbsolutePosition) ||
@@ skipping 53 matching lines @@
       offset->block_offset = inset.block_start + parent_offset_.block_offset;
       return kNewFragment;
   }
   return kNotFinished;
 }
 
 bool NGOutOfFlowLayoutPart::ComputeInlineSizeEstimate() {
   if (AbsoluteNeedsChildInlineSize(*node_->Style())) {
     MinAndMaxContentSizes size;
     if (node_->ComputeMinAndMaxContentSizes(&size)) {
-      inline_estimate_ =
-          size.ShrinkToFit(parent_space_->AvailableSize().inline_size);
+      inline_estimate_ = size;
       return true;
     }
     return false;
   }
   return true;
 }
 
 bool NGOutOfFlowLayoutPart::ComputeBlockSizeEstimate() {
   if (AbsoluteNeedsChildBlockSize(*node_->Style())) {
     if (ComputeNodeFragment()) {
@@ skipping 16 matching lines @@
     // Node fragment is computed in one of these two scenarios:
     // 1. To estimate block size
     //    In this case, available block_size is parent's size.
     // 2. To compute final block fragment, when block size is known.
 
     NGLogicalSize available_size =
         NGLogicalSize(inline_width, parent_space_->AvailableSize().block_size);
     if (block_estimate_)
       available_size.block_size = *block_estimate_;
     builder.SetAvailableSize(available_size);
-    builder.SetPercentageResolutionSize(available_size);
+    builder.SetPercentageResolutionSize(parent_space_->AvailableSize());
     if (block_estimate_)
       builder.SetIsFixedSizeBlock(true);
     builder.SetIsFixedSizeInline(true);
     builder.SetIsNewFormattingContext(true);
     node_space_ = builder.ToConstraintSpace();
   }
   NGFragment* fragment;
   if (node_->Layout(node_space_, &fragment)) {
     node_fragment_ = fragment;
     return true;
   }
   return false;
 }
 
 DEFINE_TRACE(NGOutOfFlowLayoutPart) {
   visitor->trace(node_);
   visitor->trace(parent_space_);
   visitor->trace(node_fragment_);
   visitor->trace(node_space_);
 }
 }