[css-align] Adapt the place-content shorthand to the new baseline syntax

third_party/WebKit/Source/core/css/properties/CSSPropertyAlignmentUtils.cpp

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/properties/CSSPropertyAlignmentUtils.h"
 
 #include "core/css/CSSContentDistributionValue.h"
 #include "core/css/CSSValuePair.h"
 #include "core/css/parser/CSSPropertyParserHelpers.h"
 
 namespace blink {
 
-namespace {
-
-CSSIdentifierValue* consumeSelfPositionKeyword(CSSParserTokenRange& range) {
+CSSIdentifierValue* CSSPropertyAlignmentUtils::consumeSelfPositionKeyword(
+    CSSParserTokenRange& range) {
   CSSValueID id = range.peek().id();
   if (id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter ||
       id == CSSValueSelfStart || id == CSSValueSelfEnd ||
       id == CSSValueFlexStart || id == CSSValueFlexEnd || id == CSSValueLeft ||
       id == CSSValueRight)
     return CSSPropertyParserHelpers::consumeIdent(range);
   return nullptr;
 }
 
-bool isContentDistributionKeyword(CSSValueID id) {
+bool CSSPropertyAlignmentUtils::isContentDistributionKeyword(CSSValueID id) {
   return CSSPropertyParserHelpers::identMatches<
       CSSValueSpaceBetween, CSSValueSpaceAround, CSSValueSpaceEvenly,
       CSSValueStretch>(id);
 }
 
-bool isContentPositionKeyword(CSSValueID id) {
+bool CSSPropertyAlignmentUtils::isContentPositionKeyword(CSSValueID id) {
   return CSSPropertyParserHelpers::identMatches<
       CSSValueStart, CSSValueEnd, CSSValueCenter, CSSValueFlexStart,
       CSSValueFlexEnd, CSSValueLeft, CSSValueRight>(id);
 }
 
-bool isOverflowKeyword(CSSValueID id) {
+bool CSSPropertyAlignmentUtils::isOverflowKeyword(CSSValueID id) {
   return CSSPropertyParserHelpers::identMatches<CSSValueUnsafe, CSSValueSafe>(
       id);
 }
 
-bool isBaselineKeyword(CSSValueID id) {
+bool CSSPropertyAlignmentUtils::isBaselineKeyword(CSSValueID id) {
   return CSSPropertyParserHelpers::identMatches<CSSValueFirst, CSSValueLast,
                                                 CSSValueBaseline>(id);
 }
 
-CSSValue* consumeBaselineKeyword(CSSParserTokenRange& range) {
+CSSValueID CSSPropertyAlignmentUtils::getBaselineKeyword(CSSValue& value) {
+  if (!value.isValuePair()) {
+    DCHECK(toCSSIdentifierValue(value).getValueID() == CSSValueBaseline);
+    return CSSValueBaseline;
+  }
+
+  DCHECK(toCSSIdentifierValue(toCSSValuePair(value).second()).getValueID() ==
+         CSSValueBaseline);
+  if (toCSSIdentifierValue(toCSSValuePair(value).first()).getValueID() ==
+      CSSValueLast) {
+    return CSSValueLastBaseline;
+  }
+  DCHECK(toCSSIdentifierValue(toCSSValuePair(value).first()).getValueID() ==
+         CSSValueFirst);
+  return CSSValueFirstBaseline;
+}
+
+CSSValue* CSSPropertyAlignmentUtils::consumeBaselineKeyword(
+    CSSParserTokenRange& range) {
   CSSValueID id = range.peek().id();
   if (CSSPropertyParserHelpers::identMatches<CSSValueBaseline>(id))
     return CSSPropertyParserHelpers::consumeIdent(range);
 
   if (CSSIdentifierValue* preference =
           CSSPropertyParserHelpers::consumeIdent<CSSValueFirst, CSSValueLast>(
               range)) {
     if (range.peek().id() == CSSValueBaseline) {
       return CSSValuePair::create(preference,
                                   CSSPropertyParserHelpers::consumeIdent(range),
                                   CSSValuePair::DropIdenticalValues);
     }
   }
   return nullptr;
 }
 
-}  // namespace
-
 CSSValue* CSSPropertyAlignmentUtils::consumeSelfPositionOverflowPosition(
     CSSParserTokenRange& range) {
   if (CSSPropertyParserHelpers::identMatches<CSSValueAuto, CSSValueNormal,
                                              CSSValueStretch>(
           range.peek().id()))
     return CSSPropertyParserHelpers::consumeIdent(range);
 
   if (isBaselineKeyword(range.peek().id()))
     return consumeBaselineKeyword(range);
 
@@ skipping 21 matching lines @@
   if (CSSPropertyParserHelpers::identMatches<CSSValueNormal>(id)) {
     return CSSContentDistributionValue::create(
         CSSValueInvalid, range.consumeIncludingWhitespace().id(),
         CSSValueInvalid);
   }
 
   if (isBaselineKeyword(id)) {
     CSSValue* baseline = consumeBaselineKeyword(range);
     if (!baseline)
       return nullptr;
-    CSSValueID baselineID = CSSValueBaseline;
-    if (baseline->isValuePair()) {
-      if (toCSSIdentifierValue(toCSSValuePair(baseline)->first())
-              .getValueID() == CSSValueLast) {
-        baselineID = CSSValueLastBaseline;
-      } else {
-        baselineID = CSSValueFirstBaseline;
-      }
-    }
-    return CSSContentDistributionValue::create(CSSValueInvalid, baselineID,
-                                               CSSValueInvalid);
+    return CSSContentDistributionValue::create(
+        CSSValueInvalid, getBaselineKeyword(*baseline), CSSValueInvalid);
   }
 
   CSSValueID distribution = CSSValueInvalid;
   CSSValueID position = CSSValueInvalid;
   CSSValueID overflow = CSSValueInvalid;
   do {
     if (isContentDistributionKeyword(id)) {
       if (distribution != CSSValueInvalid)
         return nullptr;
       distribution = id;
@@ skipping 19 matching lines @@
 
   // The grammar states that <overflow-position> must be associated to
   // <content-position>.
   if (overflow != CSSValueInvalid && position == CSSValueInvalid)
     return nullptr;
 
   return CSSContentDistributionValue::create(distribution, position, overflow);
 }
 
 }  // namespace blink