[css-grid] Implementing the grid's first line baseline.

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 2867 matching lines @@
   if (marginBefore.isAuto() && marginAfter.isAuto()) {
     child.setMarginBefore(availableAlignmentSpace / 2, style());
     child.setMarginAfter(availableAlignmentSpace / 2, style());
   } else if (marginBefore.isAuto()) {
     child.setMarginBefore(availableAlignmentSpace, style());
   } else if (marginAfter.isAuto()) {
     child.setMarginAfter(availableAlignmentSpace, style());
   }
 }
 
+LayoutUnit LayoutGrid::firstLineBoxBaselineForChild(

[cbiesinger, 2016/10/19 20:57:59]

Are you calling this function anywhere...?

[jfernandez, 2016/10/20 09:07:14]

Umm, you're right. This function will be used later, in the implementation
of the self-baseline alignment. It can be removed from this patch, indeed.

+    const LayoutBox& child) const {
+  LayoutUnit baseline(child.firstLineBoxBaseline());
+  // We take content-box's bottom if no valid baseline.

[cbiesinger, 2016/10/19 20:57:59]

But you're actually calculating the border-box bottom?

[jfernandez, 2016/10/20 09:07:14]

umm, as far as I know, LayoutBlock::logicalHeightForChild(child) returns
the child.size().height() which should be the content-box's height, right ? 

This function is pretty similar to the one implemented for Flexbox and
named as marginBoxAscentForChild, which it uses another Flexbox 
specific function, named as crossAxisExtentForChild which provides
the same value than LayoutBlock::logicalHeightForChild. 

I might be wrong, but as far as I understand this logic, the function
I implemented, like the Flexbox one, returns the content-box's bottom
position.

[cbiesinger, 2016/10/20 17:42:36]

No, size().height() (and logicalHeight()) all refer to the border-box size, so
that's also what the flexbox one returns. If you want the content-box, use
contentHeight().

[jfernandez, 2016/10/20 22:13:23]

Oh, I was so confused about this. I'll think about what I actually need and
probably send a new patch, since we have found out that we are not respecting
grid-order when selecting the first item (Flexbox uses document-modified-order,
instead)

+  if (baseline == -1)
+    baseline = LayoutBlock::logicalHeightForChild(child);
+  return baseline + marginBeforeForChild(child);
+}
+
+static int synthesizedBaselineFromContentBox(const LayoutBox& box,
+                                             LineDirectionMode direction) {
+  if (direction == HorizontalLine) {
+    return (box.size().height() - box.borderBottom() - box.paddingBottom() -
+            box.verticalScrollbarWidth())
+        .toInt();
+  }
+  return (box.size().width() - box.borderLeft() - box.paddingLeft() -
+          box.horizontalScrollbarHeight())
+      .toInt();
+}
+
+int LayoutGrid::baselinePosition(FontBaseline,
+                                 bool,
+                                 LineDirectionMode direction,
+                                 LinePositionMode mode) const {
+  DCHECK(mode == PositionOnContainingLine);

[cbiesinger, 2016/10/19 20:57:59]

DCHECK_EQ

[jfernandez, 2016/10/20 09:07:14]

Done.

+  int baseline = firstLineBoxBaseline();
+  // We take content-box's bottom if no valid baseline.
+  if (baseline == -1)
+    baseline = synthesizedBaselineFromContentBox(*this, direction);
+
+  return baseline + beforeMarginInLineDirection(direction);
+}
+
+int LayoutGrid::firstLineBoxBaseline() const {
+  if (isWritingModeRoot())
+    return -1;
+  const LayoutBox* baselineChild = nullptr;
+  for (const LayoutBox* child = m_orderIterator.first(); child;
+       child = m_orderIterator.next()) {
+    if (child->isOutOfFlowPositioned())
+      continue;
+    const GridSpan& rowsSpan = cachedGridSpan(*child, ForRows);
+    // TODO (lajava): propertly identifying grid items whose areas
+    // intersect the grid container's first row.
+    if (rowsSpan.startLine() > 0)
+      continue;
+    ItemPosition align = alignSelfForChild(*child).position();
+    // Orthogonal children don't participate in baseline alignment.
+    if (align == ItemPositionBaseline && !isOrthogonalChild(*child) &&
+        !hasAutoMarginsInColumnAxis(*child)) {
+      // TODO (lajava): self-baseline and content-baseline alignment
+      // still not implemented.
+      baselineChild = child;
+      break;
+    }
+    if (!baselineChild)
+      baselineChild = child;
+  }
+
+  if (!baselineChild)
+    return -1;
+
+  if (isOrthogonalChild(*baselineChild)) {
+    return ((isHorizontalWritingMode() ? baselineChild->size().height()
+                                       : baselineChild->size().width()) +
+            baselineChild->logicalTop())
+        .toInt();
+  }
+
+  int baseline = baselineChild->firstLineBoxBaseline();
+  if (baseline == -1) {
+    // TODO (lajava): We should pass |direction| into
+    // firstLineBoxBaseline and stop bailing out if we're a writing
+    // mode root.  This would also fix some cases where the grid is
+    // orthogonal to its container.
+    LineDirectionMode direction =
+        isHorizontalWritingMode() ? HorizontalLine : VerticalLine;
+    return (synthesizedBaselineFromContentBox(*baselineChild, direction) +
+            baselineChild->logicalTop())
+        .toInt();
+  }
+
+  return (baseline + baselineChild->logicalTop()).toInt();
+}
+
+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;
+}
+
 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 410 matching lines @@
   if (!m_gridItemArea.isEmpty())
     GridPainter(*this).paintChildren(paintInfo, paintOffset);
 }
 
 bool LayoutGrid::cachedHasDefiniteLogicalHeight() const {
   SECURITY_DCHECK(m_hasDefiniteLogicalHeight);
   return m_hasDefiniteLogicalHeight.value();
 }
 
 }  // namespace blink