Revert of [css-align] Don't resolve 'auto' values for computed style.

third_party/WebKit/Source/core/style/ComputedStyle.cpp

 /*
  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2011 Adobe Systems Incorporated. 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 181 matching lines @@
   bool independent_equal = old_style->IndependentInheritedEqual(*new_style);
   bool non_independent_equal =
       old_style->NonIndependentInheritedEqual(*new_style);
   if (!independent_equal || !non_independent_equal) {
     if (non_independent_equal && !old_style->HasExplicitlyInheritedProperties())
       return kIndependentInherit;
     return kInherit;
   }
 
   if (!old_style->LoadingCustomFontsEqual(*new_style) ||
+      old_style->AlignItems() != new_style->AlignItems() ||
       old_style->JustifyItems() != new_style->JustifyItems())
     return kInherit;
 
   if (*old_style == *new_style)
     return DiffPseudoStyles(*old_style, *new_style);
 
   if (old_style->HasExplicitlyInheritedProperties())
     return kInherit;
 
   return kNoInherit;
 }
 
 void ComputedStyle::PropagateIndependentInheritedProperties(
     const ComputedStyle& parent_style) {
   ComputedStyleBase::PropagateIndependentInheritedProperties(parent_style);
 }
 
 StyleSelfAlignmentData ResolvedSelfAlignment(
     const StyleSelfAlignmentData& value,
     ItemPosition normal_value_behavior) {
+  // To avoid needing to copy the RareNonInheritedData, we repurpose the 'auto'
+  // flag to not just mean 'auto' prior to running the StyleAdjuster but also
+  // mean 'normal' after running it.
   if (value.GetPosition() == kItemPositionNormal ||
       value.GetPosition() == kItemPositionAuto)
     return {normal_value_behavior, kOverflowAlignmentDefault};
   return value;
 }
 
 StyleSelfAlignmentData ComputedStyle::ResolvedAlignItems(
     ItemPosition normal_value_behaviour) const {
   // We will return the behaviour of 'normal' value if needed, which is specific
   // of each layout model.
   return ResolvedSelfAlignment(AlignItems(), normal_value_behaviour);
 }
 
 StyleSelfAlignmentData ComputedStyle::ResolvedAlignSelf(
     ItemPosition normal_value_behaviour,
     const ComputedStyle* parent_style) const {
   // We will return the behaviour of 'normal' value if needed, which is specific
   // of each layout model.
   if (!parent_style || AlignSelfPosition() != kItemPositionAuto)
     return ResolvedSelfAlignment(AlignSelf(), normal_value_behaviour);
 
+  // We shouldn't need to resolve any 'auto' value in post-adjusment
+  // ComputedStyle, but some layout models can generate anonymous boxes that may
+  // need 'auto' value resolution during layout.
   // The 'auto' keyword computes to the parent's align-items computed value.
   return parent_style->ResolvedAlignItems(normal_value_behaviour);
 }
 
 StyleSelfAlignmentData ComputedStyle::ResolvedJustifyItems(
     ItemPosition normal_value_behaviour) const {
   // We will return the behaviour of 'normal' value if needed, which is specific
   // of each layout model.
   return ResolvedSelfAlignment(JustifyItems(), normal_value_behaviour);
 }
 
 StyleSelfAlignmentData ComputedStyle::ResolvedJustifySelf(
     ItemPosition normal_value_behaviour,
     const ComputedStyle* parent_style) const {
   // We will return the behaviour of 'normal' value if needed, which is specific
   // of each layout model.
   if (!parent_style || JustifySelfPosition() != kItemPositionAuto)
     return ResolvedSelfAlignment(JustifySelf(), normal_value_behaviour);
 
+  // We shouldn't need to resolve any 'auto' value in post-adjusment
+  // ComputedStyle, but some layout models can generate anonymous boxes that may
+  // need 'auto' value resolution during layout.
   // The auto keyword computes to the parent's justify-items computed value.
   return parent_style->ResolvedJustifyItems(normal_value_behaviour);
 }
 
 static inline ContentPosition ResolvedContentAlignmentPosition(
     const StyleContentAlignmentData& value,
     const StyleContentAlignmentData& normal_value_behavior) {
   return (value.GetPosition() == kContentPositionNormal &&
           value.Distribution() == kContentDistributionDefault)
              ? normal_value_behavior.GetPosition()
@@ skipping 2148 matching lines @@
     if (value < 0)
       fvalue -= 0.5f;
     else
       fvalue += 0.5f;
   }
 
   return RoundForImpreciseConversion<int>(fvalue / zoom_factor);
 }
 
 }  // namespace blink