[css-grid] Ignore collapsed tracks on content-distribution alignment

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

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 1387 matching lines @@
   // The grid container's frame elements (border, padding and <content-position>
   // offset) are sensible to the inline-axis flow direction. However, column
   // lines positions are 'direction' unaware. This simplification allows us to
   // use the same indexes to identify the columns independently on the
   // inline-axis direction.
   bool is_row_axis = direction == kForColumns;
   auto& tracks = track_sizing_algorithm_.Tracks(direction);
   size_t number_of_tracks = tracks.size();
   size_t number_of_lines = number_of_tracks + 1;
   size_t last_line = number_of_lines - 1;
+  auto& grid = track_sizing_algorithm_.GetGrid();

[svillar, 2017/04/25 08:03:29]

Same comment, I know this was already here, but you don't need to ask the
algorithm for the grid. This method is only called from LayoutGridItems which is
called during layout so you can directly use the attribute grid_ here.

+  bool has_collapsed_tracks = grid.HasAutoRepeatEmptyTracks(direction);
+  size_t number_of_collapsed_tracks =
+      has_collapsed_tracks ? grid.AutoRepeatEmptyTracks(direction)->size() : 0;
   ContentAlignmentData offset = ComputeContentPositionAndDistributionOffset(
       direction, track_sizing_algorithm_.FreeSpace(direction).value(),
-      number_of_tracks);
+      number_of_tracks - number_of_collapsed_tracks);
   auto& positions = is_row_axis ? column_positions_ : row_positions_;
   positions.Resize(number_of_lines);
   auto border_and_padding =
       is_row_axis ? BorderAndPaddingLogicalLeft() : BorderAndPaddingBefore();
   positions[0] = border_and_padding + offset.position_offset;
-  const Grid& grid = track_sizing_algorithm_.GetGrid();
   if (number_of_lines > 1) {
     // If we have collapsed tracks we just ignore gaps here and add them later
     // as we might not compute the gap between two consecutive tracks without
     // examining the surrounding ones.
-    bool has_collapsed_tracks = grid.HasAutoRepeatEmptyTracks(direction);
     LayoutUnit gap = !has_collapsed_tracks ? GridGap(direction) : LayoutUnit();
     size_t next_to_last_line = number_of_lines - 2;
     for (size_t i = 0; i < next_to_last_line; ++i)
       positions[i + 1] = positions[i] + offset.distribution_offset +
                          tracks[i].BaseSize() + gap;
     positions[last_line] =
         positions[next_to_last_line] + tracks[next_to_last_line].BaseSize();
 
     // Adjust collapsed gaps. Collapsed tracks cause the surrounding gutters to
     // collapse (they coincide exactly) except on the edges of the grid where
     // they become 0.
     if (has_collapsed_tracks) {
       gap = GridGap(direction);
-      size_t remaining_empty_tracks =
-          grid.AutoRepeatEmptyTracks(direction)->size();
+      size_t remaining_empty_tracks = number_of_collapsed_tracks;
+      size_t last_empty_track = 0;
       LayoutUnit gap_accumulator;
       for (size_t i = 1; i < last_line; ++i) {
         if (grid.IsEmptyAutoRepeatTrack(direction, i - 1)) {
           --remaining_empty_tracks;
+          last_empty_track = i - 1;
         } else {
           // Add gap between consecutive non empty tracks. Add it also just once
           // for an arbitrary number of empty tracks between two non empty ones.
           bool all_remaining_tracks_are_empty =
               remaining_empty_tracks == (last_line - i);
           if (!all_remaining_tracks_are_empty ||
               !grid.IsEmptyAutoRepeatTrack(direction, i))
             gap_accumulator += gap;
         }
-        positions[i] += gap_accumulator;
+        positions[i] +=
+            gap_accumulator - last_empty_track * offset.distribution_offset;

[svillar, 2017/04/25 08:03:29]

I think this is wrong. Instead of the last empty track you need a counter of the
empty tracks. For example a grid with 10 tracks and track 9 is empty, when
computing the track 10 you'd be substracting 9 * offset instead just 1 offset.

       }
       positions[last_line] += gap_accumulator;
     }
   }
   auto& offset_between_tracks =
       is_row_axis ? offset_between_columns_ : offset_between_rows_;
   offset_between_tracks = offset.distribution_offset;
 }
 
 static LayoutUnit ComputeOverflowAlignmentOffset(OverflowAlignment overflow,
@@ skipping 928 matching lines @@
   if (direction == kForRows)
     return grid.NumTracks(kForRows);
 
   return grid.NumTracks(kForRows)
              ? grid.NumTracks(kForColumns)
              : GridPositionsResolver::ExplicitGridColumnCount(
                    StyleRef(), grid.AutoRepeatTracks(kForColumns));
 }
 
 }  // namespace blink