Implemented CSSPropertyAPI for transform property.

third_party/WebKit/Source/core/css/parser/CSSPropertyParser.cpp

 // Copyright 2015 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/parser/CSSPropertyParser.h"
 
 #include <memory>
 #include "core/StylePropertyShorthand.h"
 #include "core/css/CSSBasicShapeValues.h"
 #include "core/css/CSSBorderImage.h"
@@ skipping 781 matching lines @@
 
   return true;
 }
 
 static CSSValue* ConsumeBorderWidth(CSSParserTokenRange& range,
                                     CSSParserMode css_parser_mode,
                                     UnitlessQuirk unitless) {
   return ConsumeLineWidth(range, css_parser_mode, unitless);
 }
 
-static bool ConsumeTranslate3d(CSSParserTokenRange& args,
-                               CSSParserMode css_parser_mode,
-                               CSSFunctionValue*& transform_value) {
-  unsigned number_of_arguments = 2;
-  CSSValue* parsed_value = nullptr;
-  do {
-    parsed_value =
-        ConsumeLengthOrPercent(args, css_parser_mode, kValueRangeAll);
-    if (!parsed_value)
-      return false;
-    transform_value->Append(*parsed_value);
-    if (!ConsumeCommaIncludingWhitespace(args))
-      return false;
-  } while (--number_of_arguments);
-  parsed_value = ConsumeLength(args, css_parser_mode, kValueRangeAll);
-  if (!parsed_value)
-    return false;
-  transform_value->Append(*parsed_value);
-  return true;
-}
-
-static bool ConsumeNumbers(CSSParserTokenRange& args,
-                           CSSFunctionValue*& transform_value,
-                           unsigned number_of_arguments) {
-  do {
-    CSSValue* parsed_value = ConsumeNumber(args, kValueRangeAll);
-    if (!parsed_value)
-      return false;
-    transform_value->Append(*parsed_value);
-    if (--number_of_arguments && !ConsumeCommaIncludingWhitespace(args))
-      return false;
-  } while (number_of_arguments);
-  return true;
-}
-
-static bool ConsumePerspective(CSSParserTokenRange& args,
-                               const CSSParserContext* context,
-                               CSSFunctionValue*& transform_value,
-                               bool use_legacy_parsing) {
-  CSSPrimitiveValue* parsed_value =
-      ConsumeLength(args, context->Mode(), kValueRangeNonNegative);
-  if (!parsed_value && use_legacy_parsing) {
-    double perspective;
-    if (!ConsumeNumberRaw(args, perspective) || perspective < 0)
-      return false;
-    context->Count(UseCounter::kUnitlessPerspectiveInTransformProperty);
-    parsed_value = CSSPrimitiveValue::Create(
-        perspective, CSSPrimitiveValue::UnitType::kPixels);
-  }
-  if (!parsed_value)
-    return false;
-  transform_value->Append(*parsed_value);
-  return true;
-}
-
-static CSSValue* ConsumeTransformValue(CSSParserTokenRange& range,
-                                       const CSSParserContext* context,
-                                       bool use_legacy_parsing) {
-  CSSValueID function_id = range.Peek().FunctionId();
-  if (function_id == CSSValueInvalid)
-    return nullptr;
-  CSSParserTokenRange args = ConsumeFunction(range);
-  if (args.AtEnd())
-    return nullptr;
-  CSSFunctionValue* transform_value = CSSFunctionValue::Create(function_id);
-  CSSValue* parsed_value = nullptr;
-  switch (function_id) {
-    case CSSValueRotate:
-    case CSSValueRotateX:
-    case CSSValueRotateY:
-    case CSSValueRotateZ:
-    case CSSValueSkewX:
-    case CSSValueSkewY:
-    case CSSValueSkew:
-      parsed_value = ConsumeAngle(args);
-      if (!parsed_value)
-        return nullptr;
-      if (function_id == CSSValueSkew &&
-          ConsumeCommaIncludingWhitespace(args)) {
-        transform_value->Append(*parsed_value);
-        parsed_value = ConsumeAngle(args);
-        if (!parsed_value)
-          return nullptr;
-      }
-      break;
-    case CSSValueScaleX:
-    case CSSValueScaleY:
-    case CSSValueScaleZ:
-    case CSSValueScale:
-      parsed_value = ConsumeNumber(args, kValueRangeAll);
-      if (!parsed_value)
-        return nullptr;
-      if (function_id == CSSValueScale &&
-          ConsumeCommaIncludingWhitespace(args)) {
-        transform_value->Append(*parsed_value);
-        parsed_value = ConsumeNumber(args, kValueRangeAll);
-        if (!parsed_value)
-          return nullptr;
-      }
-      break;
-    case CSSValuePerspective:
-      if (!ConsumePerspective(args, context, transform_value,
-                              use_legacy_parsing))
-        return nullptr;
-      break;
-    case CSSValueTranslateX:
-    case CSSValueTranslateY:
-    case CSSValueTranslate:
-      parsed_value =
-          ConsumeLengthOrPercent(args, context->Mode(), kValueRangeAll);
-      if (!parsed_value)
-        return nullptr;
-      if (function_id == CSSValueTranslate &&
-          ConsumeCommaIncludingWhitespace(args)) {
-        transform_value->Append(*parsed_value);
-        parsed_value =
-            ConsumeLengthOrPercent(args, context->Mode(), kValueRangeAll);
-        if (!parsed_value)
-          return nullptr;
-      }
-      break;
-    case CSSValueTranslateZ:
-      parsed_value = ConsumeLength(args, context->Mode(), kValueRangeAll);
-      break;
-    case CSSValueMatrix:
-    case CSSValueMatrix3d:
-      if (!ConsumeNumbers(args, transform_value,
-                          (function_id == CSSValueMatrix3d) ? 16 : 6))
-        return nullptr;
-      break;
-    case CSSValueScale3d:
-      if (!ConsumeNumbers(args, transform_value, 3))
-        return nullptr;
-      break;
-    case CSSValueRotate3d:
-      if (!ConsumeNumbers(args, transform_value, 3) ||
-          !ConsumeCommaIncludingWhitespace(args))
-        return nullptr;
-      parsed_value = ConsumeAngle(args);
-      if (!parsed_value)
-        return nullptr;
-      break;
-    case CSSValueTranslate3d:
-      if (!ConsumeTranslate3d(args, context->Mode(), transform_value))
-        return nullptr;
-      break;
-    default:
-      return nullptr;
-  }
-  if (parsed_value)
-    transform_value->Append(*parsed_value);
-  if (!args.AtEnd())
-    return nullptr;
-  return transform_value;
-}
-
-static CSSValue* ConsumeTransform(CSSParserTokenRange& range,
-                                  const CSSParserContext* context,
-                                  bool use_legacy_parsing) {
-  if (range.Peek().Id() == CSSValueNone)
-    return ConsumeIdent(range);
-
-  CSSValueList* list = CSSValueList::CreateSpaceSeparated();
-  do {
-    CSSValue* parsed_transform_value =
-        ConsumeTransformValue(range, context, use_legacy_parsing);
-    if (!parsed_transform_value)
-      return nullptr;
-    list->Append(*parsed_transform_value);
-  } while (!range.AtEnd());
-
-  return list;
-}
-
 static CSSValue* ConsumeNoneOrURI(CSSParserTokenRange& range,
                                   const CSSParserContext* context) {
   if (range.Peek().Id() == CSSValueNone)
     return ConsumeIdent(range);
   return ConsumeUrl(range, context);
 }
 
 static CSSValue* ConsumePerspective(CSSParserTokenRange& range,
                                     const CSSParserContext* context,
                                     CSSPropertyID unresolved_property) {
@@ skipping 966 matching lines @@
     case CSSPropertyOffsetPath:
       return ConsumeOffsetPath(
           range_, context_,
           current_shorthand == CSSPropertyMotion ||
               unresolved_property == CSSPropertyAliasMotionPath);
     case CSSPropertyOffsetDistance:
       return ConsumeLengthOrPercent(range_, context_->Mode(), kValueRangeAll);
     case CSSPropertyOffsetRotate:
     case CSSPropertyOffsetRotation:
       return ConsumeOffsetRotate(range_);
-    case CSSPropertyTransform:
-      return ConsumeTransform(
-          range_, context_,
-          unresolved_property == CSSPropertyAliasWebkitTransform);
     case CSSPropertyWebkitTransformOriginX:
     case CSSPropertyWebkitPerspectiveOriginX:
       return CSSPropertyPositionUtils::ConsumePositionLonghand<CSSValueLeft,
                                                                CSSValueRight>(
           range_, context_->Mode());
     case CSSPropertyWebkitTransformOriginY:
     case CSSPropertyWebkitPerspectiveOriginY:
       return CSSPropertyPositionUtils::ConsumePositionLonghand<CSSValueTop,
                                                                CSSValueBottom>(
           range_, context_->Mode());
@@ skipping 1660 matching lines @@
     case CSSPropertyPlaceItems:
       return ConsumePlaceItemsShorthand(important);
     case CSSPropertyPlaceSelf:
       return ConsumePlaceSelfShorthand(important);
     default:
       return false;
   }
 }
 
 }  // namespace blink