Put CSSBasicShape*Value into the blink::cssvalue namespace.

This is part of the gradual process of putting all types that derive
from CSSValue into blink::cssvalue:: namespace.

Bug: 667961
Signed-off-by: Zhuoyu Qian <zhuoyu.qian@samsung.com>
Change-Id: Iefb3980ce006b1f69c326c639134fe2b7bf6426e
Reviewed-on: https://chromium-review.googlesource.com/895023Reviewed-by: Stuart Langley <slangley@chromium.org>
Reviewed-by: nainar <nainar@chromium.org>
Commit-Queue: nainar <nainar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#533220}

third_party/WebKit/Source/core/animation/BasicShapeInterpolationFunctions.cpp

@@ -173,7 +173,8 @@ enum CircleComponentIndex : unsigned {
   kCircleComponentIndexCount,
 };
 
-InterpolationValue ConvertCSSValue(const CSSBasicShapeCircleValue& circle) {
+InterpolationValue ConvertCSSValue(
+    const cssvalue::CSSBasicShapeCircleValue& circle) {
   std::unique_ptr<InterpolableList> list =
       InterpolableList::Create(kCircleComponentIndexCount);
   list->Set(kCircleCenterXIndex, ConvertCSSCoordinate(circle.CenterX()));
@@ -241,7 +242,8 @@ enum EllipseComponentIndex : unsigned {
   kEllipseComponentIndexCount,
 };
 
-InterpolationValue ConvertCSSValue(const CSSBasicShapeEllipseValue& ellipse) {
+InterpolationValue ConvertCSSValue(
+    const cssvalue::CSSBasicShapeEllipseValue& ellipse) {
   std::unique_ptr<InterpolableList> list =
       InterpolableList::Create(kEllipseComponentIndexCount);
   list->Set(kEllipseCenterXIndex, ConvertCSSCoordinate(ellipse.CenterX()));
@@ -326,7 +328,8 @@ enum InsetComponentIndex : unsigned {
   kInsetComponentIndexCount,
 };
 
-InterpolationValue ConvertCSSValue(const CSSBasicShapeInsetValue& inset) {
+InterpolationValue ConvertCSSValue(
+    const cssvalue::CSSBasicShapeInsetValue& inset) {
   std::unique_ptr<InterpolableList> list =
       InterpolableList::Create(kInsetComponentIndexCount);
   list->Set(kInsetTopIndex, ConvertCSSLength(inset.Top()));
@@ -449,7 +452,8 @@ scoped_refptr<BasicShape> CreateBasicShape(
 
 namespace PolygonFunctions {
 
-InterpolationValue ConvertCSSValue(const CSSBasicShapePolygonValue& polygon) {
+InterpolationValue ConvertCSSValue(
+    const cssvalue::CSSBasicShapePolygonValue& polygon) {
   size_t size = polygon.Values().size();
   std::unique_ptr<InterpolableList> list = InterpolableList::Create(size);
   for (size_t i = 0; i < size; i++)
@@ -506,16 +510,22 @@ scoped_refptr<BasicShape> CreateBasicShape(
 
 InterpolationValue BasicShapeInterpolationFunctions::MaybeConvertCSSValue(
     const CSSValue& value) {
-  if (value.IsBasicShapeCircleValue())
-    return CircleFunctions::ConvertCSSValue(ToCSSBasicShapeCircleValue(value));
-  if (value.IsBasicShapeEllipseValue())
+  if (value.IsBasicShapeCircleValue()) {
+    return CircleFunctions::ConvertCSSValue(
+        cssvalue::ToCSSBasicShapeCircleValue(value));
+  }
+  if (value.IsBasicShapeEllipseValue()) {
     return EllipseFunctions::ConvertCSSValue(
-        ToCSSBasicShapeEllipseValue(value));
-  if (value.IsBasicShapeInsetValue())
-    return InsetFunctions::ConvertCSSValue(ToCSSBasicShapeInsetValue(value));
-  if (value.IsBasicShapePolygonValue())
+        cssvalue::ToCSSBasicShapeEllipseValue(value));
+  }
+  if (value.IsBasicShapeInsetValue()) {
+    return InsetFunctions::ConvertCSSValue(
+        cssvalue::ToCSSBasicShapeInsetValue(value));
+  }
+  if (value.IsBasicShapePolygonValue()) {
     return PolygonFunctions::ConvertCSSValue(
-        ToCSSBasicShapePolygonValue(value));
+        cssvalue::ToCSSBasicShapePolygonValue(value));
+  }
   return nullptr;
 }
 

third_party/WebKit/Source/core/css/BasicShapeFunctions.cpp

@@ -133,8 +133,8 @@ CSSValue* ValueForBasicShape(const ComputedStyle& style,
 
     case BasicShape::kBasicShapeCircleType: {
       const BasicShapeCircle* circle = ToBasicShapeCircle(basic_shape);
-      CSSBasicShapeCircleValue* circle_value =
-          CSSBasicShapeCircleValue::Create();
+      cssvalue::CSSBasicShapeCircleValue* circle_value =
+          cssvalue::CSSBasicShapeCircleValue::Create();
 
       circle_value->SetCenterX(ValueForCenterCoordinate(
           style, circle->CenterX(), EBoxOrient::kHorizontal));
@@ -146,8 +146,8 @@ CSSValue* ValueForBasicShape(const ComputedStyle& style,
     }
     case BasicShape::kBasicShapeEllipseType: {
       const BasicShapeEllipse* ellipse = ToBasicShapeEllipse(basic_shape);
-      CSSBasicShapeEllipseValue* ellipse_value =
-          CSSBasicShapeEllipseValue::Create();
+      cssvalue::CSSBasicShapeEllipseValue* ellipse_value =
+          cssvalue::CSSBasicShapeEllipseValue::Create();
 
       ellipse_value->SetCenterX(ValueForCenterCoordinate(
           style, ellipse->CenterX(), EBoxOrient::kHorizontal));
@@ -161,8 +161,8 @@ CSSValue* ValueForBasicShape(const ComputedStyle& style,
     }
     case BasicShape::kBasicShapePolygonType: {
       const BasicShapePolygon* polygon = ToBasicShapePolygon(basic_shape);
-      CSSBasicShapePolygonValue* polygon_value =
-          CSSBasicShapePolygonValue::Create();
+      cssvalue::CSSBasicShapePolygonValue* polygon_value =
+          cssvalue::CSSBasicShapePolygonValue::Create();
 
       polygon_value->SetWindRule(polygon->GetWindRule());
       const Vector<Length>& values = polygon->Values();
@@ -175,7 +175,8 @@ CSSValue* ValueForBasicShape(const ComputedStyle& style,
     }
     case BasicShape::kBasicShapeInsetType: {
       const BasicShapeInset* inset = ToBasicShapeInset(basic_shape);
-      CSSBasicShapeInsetValue* inset_value = CSSBasicShapeInsetValue::Create();
+      cssvalue::CSSBasicShapeInsetValue* inset_value =
+          cssvalue::CSSBasicShapeInsetValue::Create();
 
       inset_value->SetTop(
           CSSPrimitiveValue::Create(inset->Top(), style.EffectiveZoom()));
@@ -287,8 +288,8 @@ scoped_refptr<BasicShape> BasicShapeForValue(
   scoped_refptr<BasicShape> basic_shape;
 
   if (basic_shape_value.IsBasicShapeCircleValue()) {
-    const CSSBasicShapeCircleValue& circle_value =
-        ToCSSBasicShapeCircleValue(basic_shape_value);
+    const cssvalue::CSSBasicShapeCircleValue& circle_value =
+        cssvalue::ToCSSBasicShapeCircleValue(basic_shape_value);
     scoped_refptr<BasicShapeCircle> circle = BasicShapeCircle::Create();
 
     circle->SetCenterX(
@@ -299,8 +300,8 @@ scoped_refptr<BasicShape> BasicShapeForValue(
 
     basic_shape = std::move(circle);
   } else if (basic_shape_value.IsBasicShapeEllipseValue()) {
-    const CSSBasicShapeEllipseValue& ellipse_value =
-        ToCSSBasicShapeEllipseValue(basic_shape_value);
+    const cssvalue::CSSBasicShapeEllipseValue& ellipse_value =
+        cssvalue::ToCSSBasicShapeEllipseValue(basic_shape_value);
     scoped_refptr<BasicShapeEllipse> ellipse = BasicShapeEllipse::Create();
 
     ellipse->SetCenterX(
@@ -314,8 +315,8 @@ scoped_refptr<BasicShape> BasicShapeForValue(
 
     basic_shape = std::move(ellipse);
   } else if (basic_shape_value.IsBasicShapePolygonValue()) {
-    const CSSBasicShapePolygonValue& polygon_value =
-        ToCSSBasicShapePolygonValue(basic_shape_value);
+    const cssvalue::CSSBasicShapePolygonValue& polygon_value =
+        cssvalue::ToCSSBasicShapePolygonValue(basic_shape_value);
     scoped_refptr<BasicShapePolygon> polygon = BasicShapePolygon::Create();
 
     polygon->SetWindRule(polygon_value.GetWindRule());
@@ -327,8 +328,8 @@ scoped_refptr<BasicShape> BasicShapeForValue(
 
     basic_shape = std::move(polygon);
   } else if (basic_shape_value.IsBasicShapeInsetValue()) {
-    const CSSBasicShapeInsetValue& rect_value =
-        ToCSSBasicShapeInsetValue(basic_shape_value);
+    const cssvalue::CSSBasicShapeInsetValue& rect_value =
+        cssvalue::ToCSSBasicShapeInsetValue(basic_shape_value);
     scoped_refptr<BasicShapeInset> rect = BasicShapeInset::Create();
 
     rect->SetTop(ConvertToLength(state, rect_value.Top()));

third_party/WebKit/Source/core/css/CSSBasicShapeValues.cpp

@@ -36,6 +36,7 @@
 #include "platform/wtf/text/StringBuilder.h"
 
 namespace blink {
+namespace cssvalue {
 
 static String BuildCircleString(const String& radius,
                                 const String& center_x,
@@ -436,4 +437,5 @@ void CSSBasicShapeInsetValue::TraceAfterDispatch(blink::Visitor* visitor) {
   CSSValue::TraceAfterDispatch(visitor);
 }
 
+}  // namespace cssvalue
 }  // namespace blink

third_party/WebKit/Source/core/css/CSSBasicShapeValues.h

@@ -39,6 +39,7 @@
 #include "platform/wtf/text/WTFString.h"
 
 namespace blink {
+namespace cssvalue {
 
 class CSSBasicShapeCircleValue final : public CSSValue {
  public:
@@ -216,6 +217,7 @@ DEFINE_CSS_VALUE_TYPE_CASTS(CSSBasicShapePolygonValue,
                             IsBasicShapePolygonValue());
 DEFINE_CSS_VALUE_TYPE_CASTS(CSSBasicShapeInsetValue, IsBasicShapeInsetValue());
 
+}  // namespace cssvalue
 }  // namespace blink
 
 #endif  // CSSBasicShapeValues_h

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

@@ -46,6 +46,9 @@
 #include "platform/wtf/text/StringBuilder.h"
 
 namespace blink {
+
+using namespace cssvalue;
+
 namespace CSSParsingUtils {
 namespace {
 
@@ -144,8 +147,7 @@ CSSValue* ConsumeSteps(CSSParserTokenRange& range) {
     return nullptr;
 
   range = range_copy;
-  return cssvalue::CSSStepsTimingFunctionValue::Create(steps->GetIntValue(),
-                                                       position);
+  return CSSStepsTimingFunctionValue::Create(steps->GetIntValue(), position);
 }
 
 CSSValue* ConsumeFrames(CSSParserTokenRange& range) {
@@ -167,7 +169,7 @@ CSSValue* ConsumeFrames(CSSParserTokenRange& range) {
     return nullptr;
 
   range = range_copy;
-  return cssvalue::CSSFramesTimingFunctionValue::Create(frames_int);
+  return CSSFramesTimingFunctionValue::Create(frames_int);
 }
 
 CSSValue* ConsumeCubicBezier(CSSParserTokenRange& range) {
@@ -187,7 +189,7 @@ CSSValue* ConsumeCubicBezier(CSSParserTokenRange& range) {
       CSSPropertyParserHelpers::ConsumeCommaIncludingWhitespace(args) &&
       CSSPropertyParserHelpers::ConsumeNumberRaw(args, y2) && args.AtEnd()) {
     range = range_copy;
-    return cssvalue::CSSCubicBezierTimingFunctionValue::Create(x1, y1, x2, y2);
+    return CSSCubicBezierTimingFunctionValue::Create(x1, y1, x2, y2);
   }
 
   return nullptr;
@@ -1168,7 +1170,7 @@ CSSValue* ConsumeBorderImageSlice(CSSParserTokenRange& range,
   CSSPropertyParserHelpers::Complete4Sides(slices);
   if (default_fill == DefaultFill::kFill)
     fill = true;
-  return cssvalue::CSSBorderImageSliceValue::Create(
+  return CSSBorderImageSliceValue::Create(
       CSSQuadValue::Create(slices[0], slices[1], slices[2], slices[3],
                            CSSQuadValue::kSerializeAsQuad),
       fill);
@@ -1573,8 +1575,7 @@ CSSValue* ConsumeFontFeatureSettings(CSSParserTokenRange& range) {
     return CSSPropertyParserHelpers::ConsumeIdent(range);
   CSSValueList* settings = CSSValueList::CreateCommaSeparated();
   do {
-    cssvalue::CSSFontFeatureValue* font_feature_value =
-        ConsumeFontFeatureTag(range);
+    CSSFontFeatureValue* font_feature_value = ConsumeFontFeatureTag(range);
     if (!font_feature_value)
       return nullptr;
     settings->Append(*font_feature_value);
@@ -1582,8 +1583,7 @@ CSSValue* ConsumeFontFeatureSettings(CSSParserTokenRange& range) {
   return settings;
 }
 
-cssvalue::CSSFontFeatureValue* ConsumeFontFeatureTag(
-    CSSParserTokenRange& range) {
+CSSFontFeatureValue* ConsumeFontFeatureTag(CSSParserTokenRange& range) {
   // Feature tag name consists of 4-letter characters.
   const unsigned kTagNameLength = 4;
 
@@ -1611,7 +1611,7 @@ cssvalue::CSSFontFeatureValue* ConsumeFontFeatureTag(
              range.Peek().Id() == CSSValueOff) {
     tag_value = range.ConsumeIncludingWhitespace().Id() == CSSValueOn;
   }
-  return cssvalue::CSSFontFeatureValue::Create(tag, tag_value);
+  return CSSFontFeatureValue::Create(tag, tag_value);
 }
 
 CSSIdentifierValue* ConsumeFontVariantCSS21(CSSParserTokenRange& range) {
@@ -2249,7 +2249,7 @@ CSSValue* ConsumePath(CSSParserTokenRange& range) {
   range = function_range;
   if (byte_stream->IsEmpty())
     return CSSIdentifierValue::Create(CSSValueNone);
-  return cssvalue::CSSPathValue::Create(std::move(byte_stream));
+  return CSSPathValue::Create(std::move(byte_stream));
 }
 
 CSSValue* ConsumeRay(CSSParserTokenRange& range,