Spec-compliant parsing and initial values for 'orphans' and 'widows'.

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 960 matching lines @@
         lineMidpointState.reset();
         resolver.setPosition(endOfLine, numberOfIsolateAncestors(endOfLine));
     }
 
     // The resolver runs should have been cleared, otherwise they're leaking.
     ASSERT(!resolver.runs().runCount());
 
     // In case we already adjusted the line positions during this layout to avoid widows
     // then we need to ignore the possibility of having a new widows situation.
     // Otherwise, we risk leaving empty containers which is against the block fragmentation principles.
-    if (paginated && !style()->hasAutoWidows() && !didBreakAtLineToAvoidWidow()) {
+    if (paginated && style()->widows() > 1 && !didBreakAtLineToAvoidWidow()) {

[mstensho (USE GERRIT), 2016/04/21 21:48:29]

The widows > 1 check here is new, but there's really no need to perform this
step if widows is 1.

         // Check the line boxes to make sure we didn't create unacceptable widows.
         // However, we'll prioritize orphans - so nothing we do here should create
         // a new orphan.
 
         RootInlineBox* lineBox = lastRootBox();
 
         // Count from the end of the block backwards, to see how many hanging
         // lines we have.
         RootInlineBox* firstLineInBlock = firstRootBox();
         int numLinesHanging = 1;
@@ skipping 19 matching lines @@
             while (lineBox && lineBox != firstLineInBlock && !lineBox->isFirstAfterPageBreak()) {
                 ++numLinesInPreviousPage;
                 lineBox = lineBox->prevRootBox();
             }
 
             // If there was an explicit value for orphans, respect that. If not, we still
             // shouldn't create a situation where we make an orphan bigger than the initial value.
             // This means that setting widows implies we also care about orphans, but given
             // the specification says the initial orphan value is non-zero, this is ok. The
             // author is always free to set orphans explicitly as well.
-            int orphans = style()->hasAutoOrphans() ? style()->initialOrphans() : style()->orphans();
+            int orphans = style()->orphans();
             int numLinesAvailable = numLinesInPreviousPage - orphans;
             if (numLinesAvailable <= 0)
                 return;
 
             int numLinesToTake = std::min(numLinesAvailable, numLinesNeeded);
             // Wind back from our first widowed line.
             lineBox = currentFirstLineOfNewPage;
             for (int i = 0; i < numLinesToTake; ++i)
                 lineBox = lineBox->prevRootBox();
 
@@ skipping 1046 matching lines @@
     if (!line || !line->isFirstLineStyle())
         return reason;
     // It's the RootInlineBox that paints the ::first-line background. Note that since it may be
     // expensive to figure out if the first line is affected by any ::first-line selectors at all,
     // we just invalidate it unconditionally, since that's typically cheaper.
     invalidateDisplayItemClient(*line);
     return reason;
 }
 
 } // namespace blink