[css-grid] Implementation of Baseline Self-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 15 matching lines @@
 #include "core/layout/LayoutGrid.h"
 
 #include "core/frame/UseCounter.h"
 #include "core/layout/LayoutState.h"
 #include "core/layout/TextAutosizer.h"
 #include "core/paint/GridPainter.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/ComputedStyle.h"
 #include "core/style/GridArea.h"
 #include "platform/LengthFunctions.h"
+#include "platform/text/WritingMode.h"
 #include "wtf/PtrUtil.h"
 #include <algorithm>
 #include <memory>
 
 namespace blink {
 
 static const int infinity = -1;
 
 class GridItemWithSpan;
 
+static inline bool isBaselinePosition(ItemPosition position) {
+  return position == ItemPositionBaseline ||
+         position == ItemPositionLastBaseline;
+}
+
 size_t LayoutGrid::Grid::numTracks(GridTrackSizingDirection direction) const {
   if (direction == ForRows)
     return m_grid.size();
   return m_grid.size() ? m_grid[0].size() : 0;
 }
 
 void LayoutGrid::Grid::ensureGridSize(size_t maximumRowSize,
                                       size_t maximumColumnSize) {
   const size_t oldRowSize = numTracks(ForRows);
   if (maximumRowSize > oldRowSize) {
@@ skipping 219 matching lines @@
   ContentAlignmentData(){};
   ContentAlignmentData(LayoutUnit position, LayoutUnit distribution)
       : positionOffset(position), distributionOffset(distribution) {}
 
   bool isValid() { return positionOffset >= 0 && distributionOffset >= 0; }
 
   LayoutUnit positionOffset = LayoutUnit(-1);
   LayoutUnit distributionOffset = LayoutUnit(-1);
 };
 
+class BaselineGroup {
+ public:
+  BaselineGroup(WritingMode blockFlow, ItemPosition childPreference)
+      : m_maxAscent(0), m_maxDescent(0), m_items() {
+    m_blockFlow = blockFlow;
+    m_preference = childPreference;
+  }
+
+  void update(const LayoutBox& child, LayoutUnit ascent, LayoutUnit descent) {
+    if (m_items.add(&child).isNewEntry) {
+      m_maxAscent = std::max(m_maxAscent, ascent);
+      m_maxDescent = std::max(m_maxDescent, descent);
+    }
+  }
+  bool isCompatible(WritingMode childBlockFlow,
+                    ItemPosition childPreference) const {
+    DCHECK(isBaselinePosition(childPreference));
+    DCHECK_GT(size(), 0);
+    return ((m_blockFlow == childBlockFlow ||
+             isOrthogonalBlockFlow(childBlockFlow)) &&
+            m_preference == childPreference) ||
+           (isOppositeBlockFlow(childBlockFlow) &&
+            m_preference != childPreference);
+  }
+
+  LayoutUnit maxAscent() const { return m_maxAscent; }
+  LayoutUnit maxDescent() const { return m_maxDescent; }
+  int size() const { return m_items.size(); }
+
+ private:
+  bool isOppositeBlockFlow(WritingMode blockFlow) const {
+    switch (blockFlow) {
+      case WritingMode::kHorizontalTb:
+        return false;
+      case WritingMode::kVerticalLr:
+        return m_blockFlow == WritingMode::kVerticalRl;
+      case WritingMode::kVerticalRl:
+        return m_blockFlow == WritingMode::kVerticalLr;
+      default:
+        NOTREACHED();
+        return false;
+    }
+  }
+  bool isOrthogonalBlockFlow(WritingMode blockFlow) const {
+    switch (blockFlow) {
+      case WritingMode::kHorizontalTb:
+        return m_blockFlow != WritingMode::kHorizontalTb;
+      case WritingMode::kVerticalLr:
+      case WritingMode::kVerticalRl:
+        return m_blockFlow == WritingMode::kHorizontalTb;
+      default:
+        NOTREACHED();
+        return false;
+    }
+  }
+
+  WritingMode m_blockFlow;
+  ItemPosition m_preference;
+  LayoutUnit m_maxAscent;
+  LayoutUnit m_maxDescent;
+  HashSet<const LayoutBox*> m_items;
+};
+
+class BaselineContext {
+ public:
+  BaselineContext(const LayoutBox& child,
+                  ItemPosition preference,
+                  LayoutUnit ascent,
+                  LayoutUnit descent) {
+    DCHECK(isBaselinePosition(preference));
+    updateSharedGroup(child, preference, ascent, descent);
+  }
+  const BaselineGroup& getSharedGroup(const LayoutBox& child,
+                                      ItemPosition preference) const {
+    DCHECK(isBaselinePosition(preference));
+    return const_cast<BaselineContext*>(this)->findCompatibleSharedGroup(
+        child, preference);
+  }
+  void updateSharedGroup(const LayoutBox& child,
+                         ItemPosition preference,
+                         LayoutUnit ascent,
+                         LayoutUnit descent) {
+    DCHECK(isBaselinePosition(preference));
+    BaselineGroup& group = findCompatibleSharedGroup(child, preference);
+    group.update(child, ascent, descent);
+  }
+
+ private:
+  // TODO Properly implement baseline-group compatibility
+  // See https://github.com/w3c/csswg-drafts/issues/721
+  BaselineGroup& findCompatibleSharedGroup(const LayoutBox& child,
+                                           ItemPosition preference) {
+    WritingMode blockDirection = child.styleRef().getWritingMode();
+    for (auto& group : m_sharedGroups) {
+      if (group.isCompatible(blockDirection, preference))
+        return group;
+    }
+    m_sharedGroups.prepend(BaselineGroup(blockDirection, preference));
+    return m_sharedGroups[0];
+  }
+
+  Vector<BaselineGroup> m_sharedGroups;
+};

[svillar, 2017/01/19 09:41:25]

These two classes have nothing to do with Grid, they're both pretty general.
Would it make sense to isolate them in a different file so they could be reused
for other LayoutObjects?

[jfernandez, 2017/01/19 16:31:48]

Acknowledged.

+
 enum TrackSizeRestriction {
   AllowInfinity,
   ForbidInfinity,
 };
 
 class LayoutGrid::GridIterator {
   WTF_MAKE_NONCOPYABLE(GridIterator);
 
  public:
   // |direction| is the direction that is fixed to |fixedTrackIndex| so e.g
@@ skipping 87 matching lines @@
   }
 
  private:
   const GridAsMatrix& m_grid;
   GridTrackSizingDirection m_direction;
   size_t m_rowIndex;
   size_t m_columnIndex;
   size_t m_childIndex;
 };
 
+typedef HashMap<unsigned,
+                std::unique_ptr<BaselineContext>,
+                DefaultHash<unsigned>::Hash,
+                WTF::UnsignedWithZeroKeyHashTraits<unsigned>>
+    BaselineContextsMap;
+
 struct LayoutGrid::GridSizingData {
   WTF_MAKE_NONCOPYABLE(GridSizingData);
   STACK_ALLOCATED();
 
  public:
   GridSizingData(size_t gridColumnCount, size_t gridRowCount, Grid& grid)
       : columnTracks(gridColumnCount), rowTracks(gridRowCount), m_grid(grid) {}
 
   Vector<GridTrack> columnTracks;
   Vector<GridTrack> rowTracks;
   Vector<size_t> contentSizedTracksIndex;
 
+  BaselineContextsMap rowAxisAlignmentContext;
+  BaselineContextsMap colAxisAlignmentContext;
+
   // Performance optimization: hold onto these Vectors until the end of Layout
   // to avoid repeated malloc / free.
   Vector<GridTrack*> filteredTracks;
   Vector<GridItemWithSpan> itemsSortedByIncreasingSpan;
   Vector<GridTrack*> growBeyondGrowthLimitsTracks;
 
   LayoutUnit& freeSpace(GridTrackSizingDirection direction) {
     return direction == ForColumns ? freeSpaceForColumns : freeSpaceForRows;
   }
 
@@ skipping 224 matching lines @@
     updateLogicalWidth();
     m_hasDefiniteLogicalHeight = hasDefiniteLogicalHeight();
 
     TextAutosizer::LayoutScope textAutosizerLayoutScope(this, &layoutScope);
 
     placeItemsOnGrid(m_grid, TrackSizing);
 
     GridSizingData sizingData(numTracks(ForColumns, m_grid),
                               numTracks(ForRows, m_grid), m_grid);
 
+    computeBaselineAlignmentContext(sizingData);
+
     // 1- First, the track sizing algorithm is used to resolve the sizes of the
     // grid columns.
     // At this point the logical width is always definite as the above call to
     // updateLogicalWidth() properly resolves intrinsic sizes. We cannot do the
     // same for heights though because many code paths inside
     // updateLogicalHeight() require a previous call to setLogicalHeight() to
     // resolve heights properly (like for positioned items for example).
     LayoutUnit availableSpaceForColumns = availableLogicalWidth();
     computeTrackSizesForDefiniteSize(ForColumns, sizingData,
                                      availableSpaceForColumns);
@@ skipping 141 matching lines @@
 
 void LayoutGrid::computeIntrinsicLogicalWidths(
     LayoutUnit& minLogicalWidth,
     LayoutUnit& maxLogicalWidth) const {
   Grid grid(this);
   placeItemsOnGrid(grid, IntrinsicSizeComputation);
 
   GridSizingData sizingData(numTracks(ForColumns, grid),
                             numTracks(ForRows, grid), grid);
 
+  computeBaselineAlignmentContext(sizingData);
   computeTrackSizesForIndefiniteSize(ForColumns, sizingData, minLogicalWidth,
                                      maxLogicalWidth);
 
   LayoutUnit scrollbarWidth = LayoutUnit(scrollbarLogicalWidth());
   minLogicalWidth += scrollbarWidth;
   maxLogicalWidth += scrollbarWidth;
 }
 
 void LayoutGrid::computeTrackSizesForIndefiniteSize(
     GridTrackSizingDirection direction,
@@ skipping 498 matching lines @@
                                                   LayoutUnit(-1));
     child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
   }
 
   // We need to clear the stretched height to properly compute logical height
   // during layout.
   if (child.needsLayout())
     child.clearOverrideLogicalContentHeight();
 
   child.layoutIfNeeded();
+  GridAxis baselineAxis =
+      isOrthogonalChild(child) ? GridRowAxis : GridColumnAxis;
+  if (isBaselineAlignmentForChild(child, baselineAxis)) {
+    auto group = getBaselineGroupForChild(child, sizingData, baselineAxis);
+    return group.maxAscent() + group.maxDescent();
+  }
   return child.logicalHeight() + child.marginLogicalHeight();
 }
 
 GridTrackSizingDirection LayoutGrid::flowAwareDirectionForChild(
     const LayoutBox& child,
     GridTrackSizingDirection direction) const {
   return !isOrthogonalChild(child)
              ? direction
              : (direction == ForColumns ? ForRows : ForColumns);
 }
@@ skipping 83 matching lines @@
 
   // All orthogonal flow boxes were already laid out during an early layout
   // phase performed in FrameView::performLayout.
   // It's true that grid track sizing was not completed at that time and it may
   // afffect the final height of a grid item, but since it's forbidden to
   // perform a layout during intrinsic width computation, we have to use that
   // computed height for now.
   if (direction == ForColumns &&
       sizingData.sizingOperation == IntrinsicSizeComputation) {
     DCHECK(isOrthogonalChild(child));
+    if (isBaselineAlignmentForChild(child, GridRowAxis)) {
+      auto group = getBaselineGroupForChild(child, sizingData, GridRowAxis);
+      return group.maxAscent() + group.maxDescent();
+    }
     return child.logicalHeight() + child.marginLogicalHeight();
   }
 
   if (updateOverrideContainingBlockContentSizeForChild(
           child, childInlineDirection, sizingData))
     child.setNeedsLayout(LayoutInvalidationReason::GridChanged);
   return logicalHeightForChild(child, sizingData);
 }
 
 DISABLE_CFI_PERF
@@ skipping 1641 matching lines @@
       .toInt();
 }
 
 static int synthesizedBaselineFromBorderBox(const LayoutBox& box,
                                             LineDirectionMode direction) {
   return (direction == HorizontalLine ? box.size().height()
                                       : box.size().width())
       .toInt();
 }
 
-// TODO(lajava): This logic is shared by LayoutFlexibleBox, so it might be
-// refactored somehow.
 int LayoutGrid::baselinePosition(FontBaseline,
                                  bool,
                                  LineDirectionMode direction,
                                  LinePositionMode mode) const {
   DCHECK_EQ(mode, PositionOnContainingLine);
   int baseline = firstLineBoxBaseline();
   // We take content-box's bottom if no valid baseline.
   if (baseline == -1)
     baseline = synthesizedBaselineFromContentBox(*this, direction);
 
   return baseline + beforeMarginInLineDirection(direction);
 }
 
-bool LayoutGrid::isInlineBaselineAlignedChild(const LayoutBox* child) const {
-  return alignSelfForChild(*child).position() == ItemPositionBaseline &&
-         !isOrthogonalChild(*child) && !hasAutoMarginsInColumnAxis(*child);
-}
-
 int LayoutGrid::firstLineBoxBaseline() const {
   if (isWritingModeRoot() || !m_grid.hasGridItems())
     return -1;
   const LayoutBox* baselineChild = nullptr;
   const LayoutBox* firstChild = nullptr;
   bool isBaselineAligned = false;
   // Finding the first grid item in grid order.
   for (size_t column = 0;
        !isBaselineAligned && column < m_grid.numTracks(ForColumns); column++) {
     for (size_t index = 0; index < m_grid.cell(0, column).size(); index++) {
       const LayoutBox* child = m_grid.cell(0, column)[index];
       DCHECK(!child->isOutOfFlowPositioned());
-      // If an item participates in baseline alignmen, we select such item.
-      if (isInlineBaselineAlignedChild(child)) {
+      // If an item participates in baseline alignment, we select such item.
+      if (isBaselineAlignmentForChild(*child)) {
         // TODO (lajava): self-baseline and content-baseline alignment
         // still not implemented.
         baselineChild = child;
         isBaselineAligned = true;
         break;
       }
       if (!baselineChild) {
         // Use dom order for items in the same cell.
         if (!firstChild || (m_grid.gridItemPaintOrder(*child) <
                             m_grid.gridItemPaintOrder(*firstChild)))
@@ skipping 29 matching lines @@
 int LayoutGrid::inlineBlockBaseline(LineDirectionMode direction) const {
   int baseline = firstLineBoxBaseline();
   if (baseline != -1)
     return baseline;
 
   int marginHeight =
       (direction == HorizontalLine ? marginTop() : marginRight()).toInt();
   return synthesizedBaselineFromContentBox(*this, direction) + marginHeight;
 }
 
+bool LayoutGrid::isHorizontalGridAxis(GridAxis axis) const {
+  return axis == GridRowAxis ? isHorizontalWritingMode()
+                             : !isHorizontalWritingMode();
+}
+
+bool LayoutGrid::isParallelToBlockAxisForChild(const LayoutBox& child,
+                                               GridAxis axis) const {
+  return axis == GridColumnAxis ? !isOrthogonalChild(child)
+                                : isOrthogonalChild(child);
+}
+
+bool LayoutGrid::isDescentBaselineForChild(const LayoutBox& child,
+                                           GridAxis baselineAxis) const {
+  return isHorizontalGridAxis(baselineAxis) &&
+         !styleRef().isFlippedBlocksWritingMode();
+}
+
+bool LayoutGrid::isBaselineAlignmentForChild(const LayoutBox& child,
+                                             GridAxis baselineAxis) const {
+  bool isColumnAxisBaseline = baselineAxis == GridColumnAxis;
+  ItemPosition align = isColumnAxisBaseline
+                           ? alignSelfForChild(child).position()
+                           : justifySelfForChild(child).position();
+  bool hasAutoMargins = isColumnAxisBaseline ? hasAutoMarginsInColumnAxis(child)
+                                             : hasAutoMarginsInRowAxis(child);
+  return isBaselinePosition(align) && !hasAutoMargins;
+}
+
+const BaselineGroup& LayoutGrid::getBaselineGroupForChild(
+    const LayoutBox& child,
+    const GridSizingData& sizingData,
+    GridAxis baselineAxis) const {
+  DCHECK(isBaselineAlignmentForChild(child, baselineAxis));
+  auto& grid = sizingData.grid();
+  bool isColumnAxisBaseline = baselineAxis == GridColumnAxis;
+  bool isRowAxisContext = isColumnAxisBaseline;
+  auto&& span = isRowAxisContext ? grid.gridItemSpan(child, ForRows)

[svillar, 2017/01/19 09:41:25]

auto&& ???

[jfernandez, 2017/01/19 16:31:48]

Since gridItemSpan returns a temporary object, we either use a const lvalue
reference, which implies copying the temporary object, or using an rvalue
reference. As we won't use/asign the span variable anymore, we can use the
rvalue reference to extend the lifetime of the temporary object and avoid the
copy operation. 

As far as I understand this rvalue reference, it only improves the code if the
type implements the "move semantics"; otherwise it's just equivalent to a const
auto&.

+                                 : grid.gridItemSpan(child, ForColumns);
+  auto& contextsMap = isRowAxisContext ? sizingData.rowAxisAlignmentContext
+                                       : sizingData.colAxisAlignmentContext;
+  auto* context = contextsMap.get(span.startLine());
+  DCHECK(context);
+  ItemPosition align = isColumnAxisBaseline
+                           ? alignSelfForChild(child).position()
+                           : justifySelfForChild(child).position();
+  return context->getSharedGroup(child, align);
+}
+
+LayoutUnit LayoutGrid::marginOverForChild(const LayoutBox& child,
+                                          GridAxis axis) const {
+  return isHorizontalGridAxis(axis) ? child.marginRight() : child.marginTop();
+}
+
+LayoutUnit LayoutGrid::logicalAscentForChild(const LayoutBox& child,
+                                             GridAxis baselineAxis) const {
+  LayoutUnit ascent = ascentForChild(child, baselineAxis);
+  return isDescentBaselineForChild(child, baselineAxis)
+             ? descentForChild(child, ascent, baselineAxis)
+             : ascent;
+}
+
+LayoutUnit LayoutGrid::ascentForChild(const LayoutBox& child,
+                                      GridAxis baselineAxis) const {
+  int baseline = isParallelToBlockAxisForChild(child, baselineAxis)
+                     ? child.firstLineBoxBaseline()
+                     : -1;
+  // We take border-box's bottom if no valid baseline.
+  if (baseline == -1) {

[svillar, 2017/01/19 09:41:25]

Unfortunate that we use the magic -1 but I guess it's what
firstLineBoxBaseline() returns now.

[jfernandez, 2017/01/19 16:31:48]

Yes, we can implement optional, as we do in WebKit, but that's clearly part of a
different patch.

+    baseline = isHorizontalGridAxis(baselineAxis)
+                   ? child.size().width().toInt()
+                   : child.size().height().toInt();
+  }
+  return LayoutUnit(baseline) + marginOverForChild(child, baselineAxis);
+}
+
+LayoutUnit LayoutGrid::descentForChild(const LayoutBox& child,
+                                       LayoutUnit ascent,
+                                       GridAxis baselineAxis) const {
+  if (isParallelToBlockAxisForChild(child, baselineAxis))
+    return child.marginLogicalHeight() + child.logicalHeight() - ascent;
+  return child.marginLogicalWidth() + child.logicalWidth() - ascent;
+}
+
+void LayoutGrid::computeBaselineAlignmentContext(
+    GridSizingData& sizingData) const {
+  for (auto* child = firstInFlowChildBox(); child;
+       child = child->nextInFlowSiblingBox()) {
+    updateBaselineAlignmentContextIfNeeded(*child, sizingData, GridRowAxis);
+    updateBaselineAlignmentContextIfNeeded(*child, sizingData, GridColumnAxis);
+  }
+}
+
+void LayoutGrid::updateBaselineAlignmentContextIfNeeded(
+    LayoutBox& child,
+    GridSizingData& sizingData,
+    GridAxis baselineAxis) const {
+  if (!isBaselineAlignmentForChild(child, baselineAxis))
+    return;
+
+  child.layoutIfNeeded();

[svillar, 2017/01/19 09:41:25]

This method is called by computeBaselineAlignmentContext which is called from
the intrinsic size code. We cannot perform layout operations during intrinsic
size computation. This should trigger an ASSERT.

[jfernandez, 2017/01/19 16:31:48]

I don't know why it doesn't. 
Anyway, what I can do it to avoid the layout operation during intrinsic size
computation, based on the GridSizingData flag.

+
+  // Determine Ascent and Descent values of this child with respect to
+  // its grid container.
+  LayoutUnit ascent = ascentForChild(child, baselineAxis);
+  LayoutUnit descent = descentForChild(child, ascent, baselineAxis);
+  if (isDescentBaselineForChild(child, baselineAxis)) {
+    LayoutUnit temp(ascent);
+    ascent = descent;
+    descent = temp;
+  }
+
+  // Looking up for a shared alignment context perpendicular to the
+  // baseline axis.
+  auto& grid = sizingData.grid();
+  bool isColumnAxisBaseline = baselineAxis == GridColumnAxis;
+  bool isRowAxisContext = isColumnAxisBaseline;
+  auto&& span = isRowAxisContext ? grid.gridItemSpan(child, ForRows)

[svillar, 2017/01/19 09:41:25]

auto&& ?

[jfernandez, 2017/01/19 16:31:48]

Already replied before.

+                                 : grid.gridItemSpan(child, ForColumns);
+  auto& contextsMap = isRowAxisContext ? sizingData.rowAxisAlignmentContext
+                                       : sizingData.colAxisAlignmentContext;
+  auto addResult = contextsMap.add(span.startLine(), nullptr);
+
+  // Looking for a compatible baseline-sharing group.
+  ItemPosition align = isColumnAxisBaseline
+                           ? alignSelfForChild(child).position()
+                           : justifySelfForChild(child).position();
+  if (addResult.isNewEntry) {
+    addResult.storedValue->value =
+        WTF::makeUnique<BaselineContext>(child, align, ascent, descent);
+  } else {
+    auto* context = addResult.storedValue->value.get();
+    context->updateSharedGroup(child, align, ascent, descent);
+  }
+}
+
+LayoutUnit LayoutGrid::columnAxisBaselineOffsetForChild(
+    const LayoutBox& child,
+    const GridSizingData& sizingData) const {
+  if (!isBaselineAlignmentForChild(child, GridColumnAxis))
+    return LayoutUnit();
+  auto& group = getBaselineGroupForChild(child, sizingData, GridColumnAxis);
+  if (group.size() > 1)
+    return group.maxAscent() - logicalAscentForChild(child, GridColumnAxis);
+  return LayoutUnit();
+}
+
+LayoutUnit LayoutGrid::rowAxisBaselineOffsetForChild(
+    const LayoutBox& child,
+    const GridSizingData& sizingData) const {
+  if (!isBaselineAlignmentForChild(child, GridRowAxis))
+    return LayoutUnit();
+  auto& group = getBaselineGroupForChild(child, sizingData, GridRowAxis);
+  if (group.size() > 1)
+    group.maxAscent() - logicalAscentForChild(child, GridRowAxis);
+  return LayoutUnit();
+}
+
 GridAxisPosition LayoutGrid::columnAxisPositionForChild(
     const LayoutBox& child) const {
   bool hasSameWritingMode =
       child.styleRef().getWritingMode() == styleRef().getWritingMode();
   bool childIsLTR = child.styleRef().isLeftToRightDirection();
 
   switch (alignSelfForChild(child).position()) {
     case ItemPositionSelfStart:
       // TODO (lajava): Should we implement this logic in a generic utility
       // function?
@@ skipping 49 matching lines @@
     // Only used in flex layout, otherwise equivalent to 'end'.
     case ItemPositionFlexEnd:
     // Aligns the alignment subject to be flush with the alignment container's
     // 'end' edge (block-end) in the column axis.
     case ItemPositionEnd:
       return GridAxisEnd;
     case ItemPositionStretch:
       return GridAxisStart;
     case ItemPositionBaseline:
     case ItemPositionLastBaseline:
-      // FIXME: These two require implementing Baseline Alignment. For now, we
-      // always 'start' align the child. crbug.com/234191
       return GridAxisStart;
     case ItemPositionAuto:
     case ItemPositionNormal:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return GridAxisStart;
 }
 
@@ skipping 57 matching lines @@
     // Only used in flex layout, otherwise equivalent to 'end'.
     case ItemPositionFlexEnd:
     // Aligns the alignment subject to be flush with the alignment container's
     // 'end' edge (inline-end) in the row axis.
     case ItemPositionEnd:
       return GridAxisEnd;
     case ItemPositionStretch:
       return GridAxisStart;
     case ItemPositionBaseline:
     case ItemPositionLastBaseline:
-      // FIXME: These two require implementing Baseline Alignment. For now, we
-      // always 'start' align the child. crbug.com/234191
       return GridAxisStart;
     case ItemPositionAuto:
     case ItemPositionNormal:
       break;
   }
 
   ASSERT_NOT_REACHED();
   return GridAxisStart;
 }
 
 LayoutUnit LayoutGrid::columnAxisOffsetForChild(
     const LayoutBox& child,
     GridSizingData& sizingData) const {
   const GridSpan& rowsSpan = sizingData.grid().gridItemSpan(child, ForRows);
   size_t childStartLine = rowsSpan.startLine();
   LayoutUnit startOfRow = m_rowPositions[childStartLine];
   LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
   if (hasAutoMarginsInColumnAxis(child))
     return startPosition;
   GridAxisPosition axisPosition = columnAxisPositionForChild(child);
   switch (axisPosition) {
     case GridAxisStart:
-      return startPosition;
+      return startPosition +
+             columnAxisBaselineOffsetForChild(child, sizingData);
     case GridAxisEnd:
     case GridAxisCenter: {
       size_t childEndLine = rowsSpan.endLine();
       LayoutUnit endOfRow = m_rowPositions[childEndLine];
       // m_rowPositions include distribution offset (because of content
       // alignment) and gutters so we need to subtract them to get the actual
       // end position for a given row (this does not have to be done for the
       // last track as there are no more m_columnPositions after it).
       LayoutUnit trackGap =
           gridGapForDirection(ForRows, sizingData.sizingOperation);
@@ skipping 23 matching lines @@
   const GridSpan& columnsSpan =
       sizingData.grid().gridItemSpan(child, ForColumns);
   size_t childStartLine = columnsSpan.startLine();
   LayoutUnit startOfColumn = m_columnPositions[childStartLine];
   LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
   if (hasAutoMarginsInRowAxis(child))
     return startPosition;
   GridAxisPosition axisPosition = rowAxisPositionForChild(child);
   switch (axisPosition) {
     case GridAxisStart:
-      return startPosition;
+      return startPosition + rowAxisBaselineOffsetForChild(child, sizingData);
     case GridAxisEnd:
     case GridAxisCenter: {
       size_t childEndLine = columnsSpan.endLine();
       LayoutUnit endOfColumn = m_columnPositions[childEndLine];
       // m_columnPositions include distribution offset (because of content
       // alignment) and gutters so we need to subtract them to get the actual
       // end position for a given column (this does not have to be done for the
       // last track as there are no more m_columnPositions after it).
       LayoutUnit trackGap =
           gridGapForDirection(ForColumns, sizingData.sizingOperation);
@@ skipping 216 matching lines @@
   if (direction == ForRows)
     return grid.numTracks(ForRows);
 
   return grid.numTracks(ForRows)
              ? grid.numTracks(ForColumns)
              : GridPositionsResolver::explicitGridColumnCount(
                    styleRef(), grid.autoRepeatTracks(ForColumns));
 }
 
 }  // namespace blink