[LayoutNG] Fix orthogonal writing mode with abs/fixed descendants.

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_box_fragment.h"
 #include "core/layout/ng/ng_constraint_space_builder.h"
@@ skipping 87 matching lines @@
 
 RefPtr<NGLayoutResult> NGOutOfFlowLayoutPart::LayoutDescendant(
     NGBlockNode& descendant,
     NGStaticPosition static_position,
     NGLogicalOffset* offset) {
   // Adjust the static_position origin. The static_position coordinate origin is
   // relative to the container's border box, ng_absolute_utils expects it to be
   // relative to the container's padding box.
   static_position.offset -= container_border_physical_offset_;
 
-  RefPtr<NGLayoutResult> layout_result = nullptr;
+  // The inline and block estimates are in the descendant's writing mode.
   Optional<MinAndMaxContentSizes> inline_estimate;
   Optional<LayoutUnit> block_estimate;
 
+  RefPtr<NGLayoutResult> layout_result = nullptr;
+  NGWritingMode descendant_writing_mode(
+      FromPlatformWritingMode(descendant.Style().getWritingMode()));
+
   if (AbsoluteNeedsChildInlineSize(descendant.Style())) {
     inline_estimate = descendant.ComputeMinAndMaxContentSizes();
   }
 
   NGAbsolutePhysicalPosition node_position =
       ComputePartialAbsoluteWithChildInlineSize(
           *container_space_, descendant.Style(), static_position,
           inline_estimate);
 
   if (AbsoluteNeedsChildBlockSize(descendant.Style())) {
     layout_result = GenerateFragment(descendant, block_estimate, node_position);
 
-    // TODO(ikilpatrick): the writing mode switching here looks wrong.
     NGBoxFragment fragment(
-        container_space_->WritingMode(),
+        descendant_writing_mode,
         toNGPhysicalBoxFragment(layout_result->PhysicalFragment().get()));
 
     block_estimate = fragment.BlockSize();
   }
 
   ComputeFullAbsoluteWithChildBlockSize(*container_space_, descendant.Style(),
                                         static_position, block_estimate,
                                         &node_position);
 
   // Skip this step if we produced a fragment when estimating the block size.
   if (!layout_result) {
     block_estimate =
-        node_position.size.ConvertToLogical(container_space_->WritingMode())
-            .block_size;
+        node_position.size.ConvertToLogical(descendant_writing_mode).block_size;
     layout_result = GenerateFragment(descendant, block_estimate, node_position);
   }
 
   // Compute logical offset, NGAbsolutePhysicalPosition is calculated relative
   // to the padding box so add back the container's borders.
   NGBoxStrut inset = node_position.inset.ConvertToLogical(
       container_space_->WritingMode(), container_space_->Direction());
   offset->inline_offset =
       inset.inline_start + container_border_offset_.inline_offset;
   offset->block_offset =
       inset.block_start + container_border_offset_.block_offset;
 
   return layout_result;
 }
 
+// The fragment is generated in one of these two scenarios:
+// 1. To estimate descendant's block size, in this case block_size is
+//    container's available size.
+// 2. To compute final fragment, when block size is known from the absolute
+//    position calculation.
 RefPtr<NGLayoutResult> NGOutOfFlowLayoutPart::GenerateFragment(
     NGBlockNode& descendant,
     const Optional<LayoutUnit>& block_estimate,
     const NGAbsolutePhysicalPosition node_position) {
-  // The fragment is generated in one of these two scenarios:
-  // 1. To estimate descendant's block size, in this case block_size is
-  //    container's available size.
-  // 2. To compute final fragment, when block size is known from the absolute
-  //    position calculation.
+  // As the block_estimate is always in the descendant's writing mode, we build
+  // the constraint space in the descendant's writing mode.
+  NGWritingMode writing_mode(
+      FromPlatformWritingMode(descendant.Style().getWritingMode()));
+  NGLogicalSize logical_available_size(
+      container_space_->AvailableSize()
+          .ConvertToPhysical(container_space_->WritingMode())
+          .ConvertToLogical(writing_mode));
+
   LayoutUnit inline_size =
-      node_position.size.ConvertToLogical(container_space_->WritingMode())
-          .inline_size;
-  LayoutUnit block_size = block_estimate
-                              ? *block_estimate
-                              : container_space_->AvailableSize().block_size;
+      node_position.size.ConvertToLogical(writing_mode).inline_size;
+  LayoutUnit block_size =
+      block_estimate ? *block_estimate : logical_available_size.block_size;
 
   NGLogicalSize available_size{inline_size, block_size};

[cbiesinger, 2017/03/03 12:58:49]

You have a variable logical_available_size and an available_size, which is also
a logical size, and they're different :/ can you rename one of them?

[ikilpatrick, 2017/03/03 17:27:06]

Sent, thanks for picking up on this. :)

 
-  NGConstraintSpaceBuilder builder(container_space_->WritingMode());
+  NGConstraintSpaceBuilder builder(writing_mode);
   builder.SetAvailableSize(available_size);
-  builder.SetPercentageResolutionSize(container_space_->AvailableSize());
+  builder.SetPercentageResolutionSize(logical_available_size);
   if (block_estimate)
     builder.SetIsFixedSizeBlock(true);
   builder.SetIsFixedSizeInline(true);
   builder.SetIsNewFormattingContext(true);
-  RefPtr<NGConstraintSpace> space =
-      builder.ToConstraintSpace(container_space_->WritingMode());
+  RefPtr<NGConstraintSpace> space = builder.ToConstraintSpace(writing_mode);
 
   return descendant.Layout(space.get());
 }
 
 }  // namespace blink