Fix incorrectly calculated size/position information for writing-modes

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"
 #include "core/layout/ng/ng_constraint_space.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
 #include "core/layout/ng/ng_fragment.h"
 #include "core/layout/ng/ng_fragment_builder.h"
 #include "core/layout/ng/ng_inline_node.h"
 #include "core/layout/ng/ng_layout_opportunity_iterator.h"
 #include "core/layout/ng/ng_length_utils.h"
 #include "core/layout/ng/ng_line_builder.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 {
 
+// Whether child's constraint space should shrink to its intrinsic width.
+// This is needed for buttons, select, input, floats and orthogonal children.
+// See LayoutBox::sizesLogicalWidthToFitContent for the rationale behind this.
+bool ShouldShrinkToFit(const NGConstraintSpace& parent_space,
+                       const ComputedStyle& child_style) {
+  NGWritingMode child_writing_mode =
+      FromPlatformWritingMode(child_style.getWritingMode());
+  // Whether the child and the containing block are parallel to each other.
+  // Example: vertical-rl and vertical-lr
+  bool is_in_parallel_flow =
+      (parent_space.WritingMode() == kHorizontalTopBottom) ==
+      (child_writing_mode == kHorizontalTopBottom);
+
+  return child_style.display() == EDisplay::InlineBlock ||
+         child_style.isFloating() || !is_in_parallel_flow;
+}
+
 // Updates the fragment's BFC offset if it's not already set.
 void UpdateFragmentBfcOffset(const NGLogicalOffset& offset,
                              const NGConstraintSpace& space,
                              NGFragmentBuilder* builder) {
   NGLogicalOffset fragment_offset =
-      space.IsNewFormattingContext() ? NGLogicalOffset() : offset;
+      space.IsNewFormattingContext() ? space.BfcOffset() : offset;
   if (!builder->BfcOffset())
     builder->SetBfcOffset(fragment_offset);
 }
 
 // Adjusts content_size to respect the CSS "clear" property.
 // Picks up the maximum between left/right exclusions and content_size depending
 // on the value of style.clear() property.
 void AdjustToClearance(const std::shared_ptr<NGExclusions>& exclusions,
                        const ComputedStyle& style,
                        const NGLogicalOffset& from_offset,
@@ skipping 328 matching lines @@
     content_size_ = border_and_padding_.block_start;
     current_child_ = first_child_;
   }
 
   curr_margin_strut_ = ConstraintSpace().MarginStrut();
   curr_bfc_offset_ = ConstraintSpace().BfcOffset();
 
   // Margins collapsing:
   //   Do not collapse margins between parent and its child if there is
   //   border/padding between them.
-  if (border_and_padding_.block_start) {
+  if (border_and_padding_.block_start ||
+      ConstraintSpace().IsNewFormattingContext()) {
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
     builder_->SetBfcOffset(curr_bfc_offset_);
     curr_margin_strut_ = NGMarginStrut();
   }
   curr_bfc_offset_.block_offset += content_size_;
 
   while (current_child_) {
     if (current_child_->Type() == NGLayoutInputNode::kLegacyBlock) {
       NGBlockNode* current_block_child = toNGBlockNode(current_child_);
       EPosition position = current_block_child->Style().position();
@@ skipping 302 matching lines @@
   NGBoxStrut margins =
       ComputeMargins(space, style, space.WritingMode(), space.Direction());
   if (!style.isFloating()) {
     ApplyAutoMargins(space, style, child_inline_size, &margins);
   }
   return margins;
 }
 
 NGConstraintSpace*
 NGBlockLayoutAlgorithm::CreateConstraintSpaceForCurrentChild() {
-  // TODO(layout-ng): Orthogonal children should also shrink to fit (in *their*
-  // inline axis)
   DCHECK(current_child_);
   if (current_child_->Type() == NGLayoutInputNode::kLegacyInline) {
     // TODO(kojii): Setup space_builder_ appropriately for inline child.
     return space_builder_->ToConstraintSpace();
+    // Calculate margins in parent's writing mode.
   }
+  curr_child_margins_ = CalculateMargins(*space_builder_->ToConstraintSpace(),
+                                         CurrentChildStyle());
 
   const ComputedStyle& current_child_style = CurrentChildStyle();
-  bool shrink_to_fit = current_child_style.display() == EDisplay::InlineBlock ||
-                       current_child_style.isFloating();
   bool is_new_bfc = IsNewFormattingContextForInFlowBlockLevelChild(
       ConstraintSpace(), current_child_style);
   space_builder_->SetIsNewFormattingContext(is_new_bfc)
-      .SetIsShrinkToFit(shrink_to_fit)
+      .SetIsShrinkToFit(
+          ShouldShrinkToFit(ConstraintSpace(), CurrentChildStyle()))
       .SetWritingMode(
           FromPlatformWritingMode(current_child_style.getWritingMode()))
       .SetTextDirection(current_child_style.direction());
   LayoutUnit space_available = SpaceAvailableForCurrentChild();
   space_builder_->SetFragmentainerSpaceAvailable(space_available);
 
-  curr_child_margins_ = CalculateMargins(*space_builder_->ToConstraintSpace(),
-                                         current_child_style);
-
   // Clearance :
   // - Collapse margins
   // - Update curr_bfc_offset and parent BFC offset if needed.
   // - Position all pending floats as position is known now.
   // TODO(glebl): Fix the use case with clear: left and an intruding right.
   // https://software.hixie.ch/utilities/js/live-dom-viewer/saved/4847
   if (current_child_style.clear() != EClear::kNone) {
     curr_bfc_offset_.block_offset += curr_margin_strut_.Sum();
     UpdateFragmentBfcOffset(curr_bfc_offset_, ConstraintSpace(),
                             builder_.get());
@@ skipping 20 matching lines @@
   curr_bfc_offset_.inline_offset += border_and_padding_.inline_start;
   if (ConstraintSpace().IsNewFormattingContext()) {
     curr_bfc_offset_.inline_offset += curr_child_margins_.inline_start;
   }
   space_builder_->SetBfcOffset(curr_bfc_offset_);
 
   return space_builder_->ToConstraintSpace();
 }
 
 }  // namespace blink