[css-align] Implement place-items alignment shorthand

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 {
 
+bool isSelfPositionKeyword(CSSValueID id) {
+  return CSSPropertyParserHelpers::identMatches<
+      CSSValueStart, CSSValueEnd, CSSValueCenter, CSSValueSelfStart,
+      CSSValueSelfEnd, CSSValueFlexStart, CSSValueFlexEnd, CSSValueLeft,
+      CSSValueRight>(id);
+}
+
 CSSIdentifierValue* 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;
+  return isSelfPositionKeyword(range.peek().id())
+             ? CSSPropertyParserHelpers::consumeIdent(range)
+             : nullptr;
+}
+
+bool isAutoOrNormalOrStretch(CSSValueID id) {
+  return CSSPropertyParserHelpers::identMatches<CSSValueAuto, CSSValueNormal,
+                                                CSSValueStretch>(id);
 }
 
 bool isContentDistributionKeyword(CSSValueID id) {
   return CSSPropertyParserHelpers::identMatches<
       CSSValueSpaceBetween, CSSValueSpaceAround, CSSValueSpaceEvenly,
       CSSValueStretch>(id);
 }
 
 bool isContentPositionKeyword(CSSValueID id) {
   return CSSPropertyParserHelpers::identMatches<
@@ skipping 42 matching lines @@
                                   CSSValuePair::DropIdenticalValues);
     }
   }
   return nullptr;
 }
 
 }  // namespace
 
 CSSValue* CSSPropertyAlignmentUtils::consumeSelfPositionOverflowPosition(
     CSSParserTokenRange& range) {
-  if (CSSPropertyParserHelpers::identMatches<CSSValueAuto, CSSValueNormal,
-                                             CSSValueStretch>(
-          range.peek().id()))
+  CSSValueID id = range.peek().id();
+  if (isAutoOrNormalOrStretch(id))
     return CSSPropertyParserHelpers::consumeIdent(range);
 
-  if (isBaselineKeyword(range.peek().id()))
+  if (isBaselineKeyword(id))
     return consumeBaselineKeyword(range);
 
   CSSIdentifierValue* overflowPosition =
       CSSPropertyParserHelpers::consumeIdent<CSSValueUnsafe, CSSValueSafe>(
           range);
   CSSIdentifierValue* selfPosition = consumeSelfPositionKeyword(range);
   if (!selfPosition)
     return nullptr;
   if (!overflowPosition) {
     overflowPosition =
         CSSPropertyParserHelpers::consumeIdent<CSSValueUnsafe, CSSValueSafe>(
             range);
   }
   if (overflowPosition) {
     return CSSValuePair::create(selfPosition, overflowPosition,
                                 CSSValuePair::DropIdenticalValues);
   }
   return selfPosition;
 }
 
+CSSValue* CSSPropertyAlignmentUtils::consumeSimplifiedItemPosition(
+    CSSParserTokenRange& range) {
+  CSSValueID id = range.peek().id();
+  if (isAutoOrNormalOrStretch(id))
+    return CSSPropertyParserHelpers::consumeIdent(range);
+
+  if (isBaselineKeyword(id))
+    return consumeBaselineKeyword(range);
+
+  return consumeSelfPositionKeyword(range);
+}
+
 CSSValue* CSSPropertyAlignmentUtils::consumeContentDistributionOverflowPosition(
     CSSParserTokenRange& range) {
   CSSValueID id = range.peek().id();
   if (CSSPropertyParserHelpers::identMatches<CSSValueNormal>(id)) {
     return CSSContentDistributionValue::create(
         CSSValueInvalid, range.consumeIncludingWhitespace().id(),
         CSSValueInvalid);
   }
 
   if (isBaselineKeyword(id)) {
@@ skipping 60 matching lines @@
 
   if (isContentDistributionKeyword(id)) {
     return CSSContentDistributionValue::create(
         range.consumeIncludingWhitespace().id(), CSSValueInvalid,
         CSSValueInvalid);
   }
   return nullptr;
 }
 
 }  // namespace blink