Fix text-align: center/right when line wraps at atomic inline and spaces

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

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
  *               All right reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 365 matching lines @@
       return ETextAlign::kJustify;
     case TextAlignLastAuto:
       if (alignment == ETextAlign::kJustify)
         return ETextAlign::kStart;
       return alignment;
   }
 
   return alignment;
 }
 
+static bool textAlignmentNeedsTrailingSpace(ETextAlign textAlign,
+                                            const ComputedStyle& style) {
+  switch (textAlign) {
+    case ETextAlign::kLeft:
+    case ETextAlign::kWebkitLeft:
+      return false;
+    case ETextAlign::kRight:
+    case ETextAlign::kWebkitRight:
+    case ETextAlign::kCenter:
+    case ETextAlign::kWebkitCenter:
+    case ETextAlign::kJustify:
+      return style.collapseWhiteSpace();
+    case ETextAlign::kStart:
+      return style.collapseWhiteSpace() && !style.isLeftToRightDirection();
+    case ETextAlign::kEnd:
+      return style.collapseWhiteSpace() && style.isLeftToRightDirection();
+  }
+  NOTREACHED();
+  return false;
+}
+
 static void updateLogicalWidthForLeftAlignedBlock(
     bool isLeftToRightDirection,
     BidiRun* trailingSpaceRun,
     LayoutUnit& logicalLeft,
     LayoutUnit totalLogicalWidth,
     LayoutUnit availableLogicalWidth) {
   // The direction of the block should determine what happens with wide lines.
   // In particular with RTL blocks, wide lines should still spill out to the
   // left.
   if (isLeftToRightDirection) {
@@ skipping 349 matching lines @@
 
 void LayoutBlockFlow::computeInlineDirectionPositionsForLine(
     RootInlineBox* lineBox,
     const LineInfo& lineInfo,
     BidiRun* firstRun,
     BidiRun* trailingSpaceRun,
     bool reachedEnd,
     GlyphOverflowAndFallbackFontsMap& textBoxDataMap,
     VerticalPositionCache& verticalPositionCache,
     const WordMeasurements& wordMeasurements) {
-  ETextAlign textAlign =
-      textAlignmentForLine(!reachedEnd && !lineBox->endsWithBreak());
 
   // CSS 2.1: "'Text-indent' only affects a line if it is the first formatted
   // line of an element. For example, the first line of an anonymous block
   // box is only affected if it is the first child of its parent element."
   // CSS3 "text-indent", "each-line" affects the first line of the block
   // container as well as each line after a forced line break, but does not
   // affect lines after a soft wrap break.
   bool isFirstLine =
       lineInfo.isFirstLine() &&
       !(isAnonymousBlock() && parent()->slowFirstChild() != this);
@@ skipping 10 matching lines @@
   bool needsWordSpacing;
 
   if (firstRun && firstRun->m_lineLayoutItem.isAtomicInlineLevel()) {
     LineLayoutBox layoutBox(firstRun->m_lineLayoutItem);
     updateLogicalInlinePositions(this, lineLogicalLeft, lineLogicalRight,
                                  availableLogicalWidth, isFirstLine, indentText,
                                  layoutBox.logicalHeight());
   }
 
   computeInlineDirectionPositionsForSegment(
-      lineBox, lineInfo, textAlign, lineLogicalLeft, availableLogicalWidth,
-      firstRun, trailingSpaceRun, textBoxDataMap, verticalPositionCache,
+      lineBox, lineInfo, lineLogicalLeft, availableLogicalWidth, firstRun,
+      trailingSpaceRun, textBoxDataMap, verticalPositionCache,
       wordMeasurements);
   // The widths of all runs are now known. We can now place every inline box
   // (and compute accurate widths for the inline flow boxes).
   needsWordSpacing = lineBox->isLeftToRightDirection() ? false : true;
   lineBox->placeBoxesInInlineDirection(lineLogicalLeft, needsWordSpacing);
 }
 
 BidiRun* LayoutBlockFlow::computeInlineDirectionPositionsForSegment(
     RootInlineBox* lineBox,
     const LineInfo& lineInfo,
-    ETextAlign textAlign,
     LayoutUnit& logicalLeft,
     LayoutUnit& availableLogicalWidth,
     BidiRun* firstRun,
     BidiRun* trailingSpaceRun,
     GlyphOverflowAndFallbackFontsMap& textBoxDataMap,
     VerticalPositionCache& verticalPositionCache,
     const WordMeasurements& wordMeasurements) {
   bool needsWordSpacing = true;
   LayoutUnit totalLogicalWidth = lineBox->getFlowSpacingLogicalWidth();
   bool isAfterExpansion = true;
   ExpansionOpportunities expansions;
   LayoutObject* previousObject = nullptr;
+  ETextAlign textAlign = lineInfo.textAlign();
   TextJustify textJustify = style()->getTextJustify();
 
   BidiRun* r = firstRun;
   size_t wordMeasurementsIndex = 0;
   for (; r; r = r->next()) {
     if (!r->m_box || r->m_lineLayoutItem.isOutOfFlowPositioned() ||
         r->m_box->isLineBreak()) {
       continue;  // Positioned objects are only participating to figure out
                  // their correct static x position. They have no effect on the
                  // width. Similarly, line break boxes have no effect on the
@@ skipping 331 matching lines @@
                : NoVisualOverride);
       if (isNewUBAParagraph &&
           styleToUse.getUnicodeBidi() == UnicodeBidi::kPlaintext &&
           !resolver.context()->parent()) {
         TextDirection direction = determinePlaintextDirectionality(
             resolver.position().root(), resolver.position().getLineLayoutItem(),
             resolver.position().offset());
         resolver.setStatus(
             BidiStatus(direction, isOverride(styleToUse.getUnicodeBidi())));
       }
+
+      ETextAlign textAlign = textAlignmentForLine(
+          !endOfLine.atEnd() &&
+          !layoutState.lineInfo().previousLineBrokeCleanly());
+      layoutState.lineInfo().setTextAlign(textAlign);
+      resolver.setNeedsTrailingSpace(
+          textAlignmentNeedsTrailingSpace(textAlign, styleToUse));
+
       // FIXME: This ownership is reversed. We should own the BidiRunList and
       // pass it to createBidiRunsForLine.
       BidiRunList<BidiRun>& bidiRuns = resolver.runs();
       constructBidiRunsForLine(
           resolver, bidiRuns, endOfLine, override,
           layoutState.lineInfo().previousLineBrokeCleanly(), isNewUBAParagraph);
       ASSERT(resolver.position() == endOfLine);
 
       BidiRun* trailingSpaceRun = resolver.trailingSpaceRun();
 
@@ skipping 1418 matching lines @@
 
 bool LayoutBlockFlow::paintedOutputOfObjectHasNoEffectRegardlessOfSize() const {
   // LayoutBlockFlow is in charge of paint invalidation of the first line.
   if (firstLineBox())
     return false;
 
   return LayoutBlock::paintedOutputOfObjectHasNoEffectRegardlessOfSize();
 }
 
 }  // namespace blink