[css-grid] Fix behavior of positioned items without specific dimensions

third_party/WebKit/Source/core/layout/LayoutBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 57 matching lines @@
 #include "platform/geometry/DoubleRect.h"
 #include "platform/geometry/FloatQuad.h"
 #include "platform/geometry/FloatRoundedRect.h"
 #include "platform/wtf/PtrUtil.h"
 
 namespace blink {
 
 // Used by flexible boxes when flexing this element and by table cells.
 typedef WTF::HashMap<const LayoutBox*, LayoutUnit> OverrideSizeMap;
 
-static OverrideSizeMap* g_extra_inline_offset_map = nullptr;
-static OverrideSizeMap* g_extra_block_offset_map = nullptr;
-
 // Size of border belt for autoscroll. When mouse pointer in border belt,
 // autoscroll is started.
 static const int kAutoscrollBeltSize = 20;
 static const unsigned kBackgroundObscurationTestMaxDepth = 4;
 
 struct SameSizeAsLayoutBox : public LayoutBoxModelObject {
   LayoutRect frame_rect;
   LayoutSize previous_size;
   LayoutUnit intrinsic_content_logical_height;
   LayoutRectOutsets margin_box_outsets;
@@ skipping 26 matching lines @@
 
   if (HasOverflowClip())
     return kOverflowClipPaintLayer;
 
   return kNoPaintLayer;
 }
 
 void LayoutBox::WillBeDestroyed() {
   ClearOverrideSize();
   ClearContainingBlockOverrideSize();
-  ClearExtraInlineAndBlockOffests();
 
   if (IsOutOfFlowPositioned())
     LayoutBlock::RemovePositionedObject(this);
   RemoveFromPercentHeightContainer();
   if (IsOrthogonalWritingModeRoot() && !DocumentBeingDestroyed())
     UnmarkOrthogonalWritingModeRoot();
 
   ShapeOutsideInfo::RemoveInfo(*this);
 
   LayoutBoxModelObject::WillBeDestroyed();
@@ skipping 1300 matching lines @@
 
 // TODO (lajava) Shouldn't we implement these functions based on physical
 // direction ?.
 void LayoutBox::ClearOverrideContainingBlockContentLogicalHeight() {
   if (!rare_data_)
     return;
   EnsureRareData().has_override_containing_block_content_logical_height_ =
       false;
 }
 
-LayoutUnit LayoutBox::ExtraInlineOffset() const {
-  return g_extra_inline_offset_map ? g_extra_inline_offset_map->at(this)
-                                   : LayoutUnit();
-}
-
-LayoutUnit LayoutBox::ExtraBlockOffset() const {
-  return g_extra_block_offset_map ? g_extra_block_offset_map->at(this)
-                                  : LayoutUnit();
-}
-
-void LayoutBox::SetExtraInlineOffset(LayoutUnit inline_offest) {
-  if (!g_extra_inline_offset_map)
-    g_extra_inline_offset_map = new OverrideSizeMap;
-  g_extra_inline_offset_map->Set(this, inline_offest);
-}
-
-void LayoutBox::SetExtraBlockOffset(LayoutUnit block_offest) {
-  if (!g_extra_block_offset_map)
-    g_extra_block_offset_map = new OverrideSizeMap;
-  g_extra_block_offset_map->Set(this, block_offest);
-}
-
-void LayoutBox::ClearExtraInlineAndBlockOffests() {
-  if (g_extra_inline_offset_map)
-    g_extra_inline_offset_map->erase(this);
-  if (g_extra_block_offset_map)
-    g_extra_block_offset_map->erase(this);
-}
-
 LayoutUnit LayoutBox::AdjustBorderBoxLogicalWidthForBoxSizing(
     float width) const {
   LayoutUnit borders_plus_padding = CollapsedBorderAndCSSPaddingLogicalWidth();
   LayoutUnit result(width);
   if (Style()->BoxSizing() == EBoxSizing::kContentBox)
     return result + borders_plus_padding;
   return std::max(result, borders_plus_padding);
 }
 
 LayoutUnit LayoutBox::AdjustBorderBoxLogicalHeightForBoxSizing(
@@ skipping 2402 matching lines @@
 
 void LayoutBox::ComputeInlineStaticDistance(
     Length& logical_left,
     Length& logical_right,
     const LayoutBox* child,
     const LayoutBoxModelObject* container_block,
     LayoutUnit container_logical_width) {
   if (!logical_left.IsAuto() || !logical_right.IsAuto())
     return;
 
+  LayoutObject* parent = child->Parent();
+  TextDirection parent_direction = parent->Style()->Direction();
+
+  // This method is using EnclosingBox() which is wrong for absolutely
+  // positioned grid items, as they rely on the grid area. So for grid items if
+  // both "left" and "right" properties are "auto", we can consider that one of
+  // them (depending on the direction) is simply "0".
+  if (parent->IsLayoutGrid() && parent == child->ContainingBlock()) {
+    if (parent_direction == TextDirection::kLtr)
+      logical_left.SetValue(kFixed, 0);
+    else
+      logical_right.SetValue(kFixed, 0);
+    return;
+  }
+
   // For multicol we also need to keep track of the block position, since that
   // determines which column we're in and thus affects the inline position.
   LayoutUnit static_block_position = child->Layer()->StaticBlockPosition();
 
   // FIXME: The static distance computation has not been patched for mixed
   // writing modes yet.
-  if (child->Parent()->Style()->Direction() == TextDirection::kLtr) {
+  if (parent_direction == TextDirection::kLtr) {
     LayoutUnit static_position = child->Layer()->StaticInlinePosition() -
                                  container_block->BorderLogicalLeft();
     for (LayoutObject* curr = child->Parent(); curr && curr != container_block;
          curr = curr->Container()) {
       if (curr->IsBox()) {
         static_position += ToLayoutBox(curr)->LogicalLeft();
         if (ToLayoutBox(curr)->IsInFlowPositioned())
           static_position +=
               ToLayoutBox(curr)->OffsetForInFlowPosition().Width();
         if (curr->IsInsideFlowThread())
@@ skipping 155 matching lines @@
         margin_logical_right, min_values);
 
     if (computed_values.extent_ < min_values.extent_) {
       computed_values.extent_ = min_values.extent_;
       computed_values.position_ = min_values.position_;
       computed_values.margins_.start_ = min_values.margins_.start_;
       computed_values.margins_.end_ = min_values.margins_.end_;
     }
   }
 
-  if (!Style()->HasStaticInlinePosition(is_horizontal))
-    computed_values.position_ += ExtraInlineOffset();
-
   computed_values.extent_ += borders_plus_padding;
 }
 
 void LayoutBox::ComputeLogicalLeftPositionedOffset(
     LayoutUnit& logical_left_pos,
     const LayoutBox* child,
     LayoutUnit logical_width_value,
     const LayoutBoxModelObject* container_block,
     LayoutUnit container_logical_width) {
   // Deal with differing writing modes here. Our offset needs to be in the
@@ skipping 385 matching lines @@
         min_values);
 
     if (computed_values.extent_ < min_values.extent_) {
       computed_values.extent_ = min_values.extent_;
       computed_values.position_ = min_values.position_;
       computed_values.margins_.before_ = min_values.margins_.before_;
       computed_values.margins_.after_ = min_values.margins_.after_;
     }
   }
 
-  if (!Style()->HasStaticBlockPosition(IsHorizontalWritingMode()))
-    computed_values.position_ += ExtraBlockOffset();
-
   // Set final height value.
   computed_values.extent_ += borders_plus_padding;
 }
 
 void LayoutBox::ComputeLogicalTopPositionedOffset(
     LayoutUnit& logical_top_pos,
     const LayoutBox* child,
     LayoutUnit logical_height_value,
     const LayoutBoxModelObject* container_block,
     LayoutUnit container_logical_height) {
@@ skipping 1398 matching lines @@
 void LayoutBox::MutableForPainting::
     SavePreviousContentBoxSizeAndLayoutOverflowRect() {
   auto& rare_data = GetLayoutBox().EnsureRareData();
   rare_data.has_previous_content_box_size_and_layout_overflow_rect_ = true;
   rare_data.previous_content_box_size_ = GetLayoutBox().ContentBoxRect().Size();
   rare_data.previous_layout_overflow_rect_ =
       GetLayoutBox().LayoutOverflowRect();
 }
 
 }  // namespace blink