Remove using directives ("using namespace x") from renderer/core/css/parser/.

Bug: 82078
Change-Id: Ie7c619084a2b70ff5e4c377bc525d663c2c2b1bb
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1872727Reviewed-by: Rune Lillesveen <futhark@chromium.org>
Commit-Queue: Rune Lillesveen <futhark@chromium.org>
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Cr-Commit-Position: refs/heads/master@{#708111}

third_party/blink/renderer/core/css/parser/css_parser.cc

@@ -23,8 +23,6 @@
 
 namespace blink {
 
-using namespace cssvalue;
-
 bool CSSParser::ParseDeclarationList(const CSSParserContext* context,
                                      MutableCSSPropertyValueSet* property_set,
                                      const String& declaration) {
@@ -245,7 +243,7 @@ bool CSSParser::ParseColor(Color& color, const String& string, bool strict) {
         StrictCSSParserContext(SecureContextMode::kInsecureContext));
   }
 
-  auto* color_value = DynamicTo<CSSColorValue>(value);
+  auto* color_value = DynamicTo<cssvalue::CSSColorValue>(value);
   if (!color_value)
     return false;
 

third_party/blink/renderer/core/css/parser/css_parser_fast_paths.cc

@@ -24,8 +24,6 @@
 
 namespace blink {
 
-using namespace cssvalue;
-
 static inline bool IsSimpleLengthPropertyID(CSSPropertyID property_id,
                                             bool& accepts_negative_numbers) {
   switch (property_id) {
@@ -532,7 +530,7 @@ CSSValue* CSSParserFastPaths::ParseColor(const String& string,
                                           string.length(), quirks_mode);
   if (!parse_result)
     return nullptr;
-  return CSSColorValue::Create(color);
+  return cssvalue::CSSColorValue::Create(color);
 }
 
 bool CSSParserFastPaths::IsValidKeywordPropertyAndValue(

third_party/blink/renderer/core/css/parser/css_parser_fast_paths_test.cc

@@ -11,8 +11,6 @@
 
 namespace blink {
 
-using namespace cssvalue;
-
 TEST(CSSParserFastPathsTest, ParseKeyword) {
   CSSValue* value = CSSParserFastPaths::MaybeParseValue(
       CSSPropertyID::kFloat, "left", kHTMLStandardMode);
@@ -116,7 +114,7 @@ TEST(CSSParserFastPathsTest, ParseColorWithLargeAlpha) {
                                                    kHTMLStandardMode);
   EXPECT_NE(nullptr, value);
   EXPECT_TRUE(value->IsColorValue());
-  EXPECT_EQ(Color::kBlack, To<CSSColorValue>(*value).Value());
+  EXPECT_EQ(Color::kBlack, To<cssvalue::CSSColorValue>(*value).Value());
 }
 
 TEST(CSSParserFastPathsTest, ParseColorWithNewSyntax) {
@@ -124,27 +122,27 @@ TEST(CSSParserFastPathsTest, ParseColorWithNewSyntax) {
       CSSParserFastPaths::ParseColor("rgba(0 0 0)", kHTMLStandardMode);
   EXPECT_NE(nullptr, value);
   EXPECT_TRUE(value->IsColorValue());
-  EXPECT_EQ(Color::kBlack, To<CSSColorValue>(*value).Value());
+  EXPECT_EQ(Color::kBlack, To<cssvalue::CSSColorValue>(*value).Value());
 
   value = CSSParserFastPaths::ParseColor("rgba(0 0 0 / 1)", kHTMLStandardMode);
   EXPECT_NE(nullptr, value);
   EXPECT_TRUE(value->IsColorValue());
-  EXPECT_EQ(Color::kBlack, To<CSSColorValue>(*value).Value());
+  EXPECT_EQ(Color::kBlack, To<cssvalue::CSSColorValue>(*value).Value());
 
   value = CSSParserFastPaths::ParseColor("rgba(0, 0, 0, 1)", kHTMLStandardMode);
   EXPECT_NE(nullptr, value);
   EXPECT_TRUE(value->IsColorValue());
-  EXPECT_EQ(Color::kBlack, To<CSSColorValue>(*value).Value());
+  EXPECT_EQ(Color::kBlack, To<cssvalue::CSSColorValue>(*value).Value());
 
   value = CSSParserFastPaths::ParseColor("RGBA(0 0 0 / 1)", kHTMLStandardMode);
   EXPECT_NE(nullptr, value);
   EXPECT_TRUE(value->IsColorValue());
-  EXPECT_EQ(Color::kBlack, To<CSSColorValue>(*value).Value());
+  EXPECT_EQ(Color::kBlack, To<cssvalue::CSSColorValue>(*value).Value());
 
   value = CSSParserFastPaths::ParseColor("RGB(0 0 0 / 1)", kHTMLStandardMode);
   EXPECT_NE(nullptr, value);
   EXPECT_TRUE(value->IsColorValue());
-  EXPECT_EQ(Color::kBlack, To<CSSColorValue>(*value).Value());
+  EXPECT_EQ(Color::kBlack, To<cssvalue::CSSColorValue>(*value).Value());
 
   value = CSSParserFastPaths::ParseColor("rgba(0 0 0 0)", kHTMLStandardMode);
   EXPECT_EQ(nullptr, value);
@@ -165,25 +163,25 @@ TEST(CSSParserFastPathsTest, ParseColorWithDecimal) {
                                                    kHTMLStandardMode);
   EXPECT_NE(nullptr, value);
   EXPECT_TRUE(value->IsColorValue());
-  EXPECT_EQ(Color::kBlack, To<CSSColorValue>(*value).Value());
+  EXPECT_EQ(Color::kBlack, To<cssvalue::CSSColorValue>(*value).Value());
 
   value =
       CSSParserFastPaths::ParseColor("rgb(0.0, 0.0, 0.0)", kHTMLStandardMode);
   EXPECT_NE(nullptr, value);
   EXPECT_TRUE(value->IsColorValue());
-  EXPECT_EQ(Color::kBlack, To<CSSColorValue>(*value).Value());
+  EXPECT_EQ(Color::kBlack, To<cssvalue::CSSColorValue>(*value).Value());
 
   value =
       CSSParserFastPaths::ParseColor("rgb(0.0 , 0.0,0.0)", kHTMLStandardMode);
   EXPECT_NE(nullptr, value);
   EXPECT_TRUE(value->IsColorValue());
-  EXPECT_EQ(Color::kBlack, To<CSSColorValue>(*value).Value());
+  EXPECT_EQ(Color::kBlack, To<cssvalue::CSSColorValue>(*value).Value());
 
   value = CSSParserFastPaths::ParseColor("rgb(254.5, 254.5, 254.5)",
                                          kHTMLStandardMode);
   EXPECT_NE(nullptr, value);
   EXPECT_TRUE(value->IsColorValue());
-  EXPECT_EQ(Color::kWhite, To<CSSColorValue>(*value).Value());
+  EXPECT_EQ(Color::kWhite, To<cssvalue::CSSColorValue>(*value).Value());
 }
 
 }  // namespace blink

third_party/blink/renderer/core/css/parser/css_parser_proto_fuzzer.cc

@@ -17,12 +17,11 @@
 
 protobuf_mutator::protobuf::LogSilencer log_silencer;
 
-using namespace css_proto_converter;
+using css_proto_converter::Input;
 
 DEFINE_BINARY_PROTO_FUZZER(const Input& input) {
-  static Converter converter = Converter();
-  static blink::BlinkFuzzerTestSupport test_support =
-      blink::BlinkFuzzerTestSupport();
+  static css_proto_converter::Converter converter;
+  static blink::BlinkFuzzerTestSupport test_support;
 
   static std::unordered_map<Input::CSSParserMode, blink::CSSParserMode>
       parser_mode_map = {
@@ -41,25 +40,19 @@ DEFINE_BINARY_PROTO_FUZZER(const Input& input) {
   blink::CSSParserMode mode = parser_mode_map[input.css_parser_mode()];
   blink::SecureContextMode secure_context_mode =
       secure_context_mode_map[input.secure_context_mode()];
-  blink::CSSParserContext::SelectorProfile selector_profile;
-  if (input.is_live_profile())
-    selector_profile = blink::CSSParserContext::kLiveProfile;
-  else
-    selector_profile = blink::CSSParserContext::kSnapshotProfile;
-  blink::CSSDeferPropertyParsing defer_property_parsing;
-  if (input.defer_property_parsing())
-    defer_property_parsing = blink::CSSDeferPropertyParsing::kYes;
-  else
-    defer_property_parsing = blink::CSSDeferPropertyParsing::kNo;
+  const blink::CSSParserContext::SelectorProfile selector_profile =
+      input.is_live_profile() ? blink::CSSParserContext::kLiveProfile
+                              : blink::CSSParserContext::kSnapshotProfile;
   auto* context = blink::MakeGarbageCollected<blink::CSSParserContext>(
       mode, secure_context_mode, selector_profile);
 
   auto* style_sheet =
       blink::MakeGarbageCollected<blink::StyleSheetContents>(context);
-
   WTF::String style_sheet_string(
       converter.Convert(input.style_sheet()).c_str());
-
+  const blink::CSSDeferPropertyParsing defer_property_parsing =
+      input.defer_property_parsing() ? blink::CSSDeferPropertyParsing::kYes
+                                     : blink::CSSDeferPropertyParsing::kNo;
   blink::CSSParser::ParseSheet(context, style_sheet, style_sheet_string,
                                defer_property_parsing);
 }

third_party/blink/renderer/core/css/parser/css_property_parser.cc

@@ -23,7 +23,9 @@
 
 namespace blink {
 
-using namespace css_property_parser_helpers;
+using css_property_parser_helpers::ConsumeIdent;
+using css_property_parser_helpers::IsImplicitProperty;
+using css_property_parser_helpers::ParseLonghand;
 
 class CSSIdentifierValue;
 
@@ -156,8 +158,8 @@ bool CSSPropertyParser::ParseValueStart(CSSPropertyID unresolved_property,
     if (is_shorthand) {
       const cssvalue::CSSPendingSubstitutionValue& pending_value =
           *cssvalue::CSSPendingSubstitutionValue::Create(property_id, variable);
-      AddExpandedPropertyForValue(property_id, pending_value, important,
-                                  *parsed_properties_);
+      css_property_parser_helpers::AddExpandedPropertyForValue(
+          property_id, pending_value, important, *parsed_properties_);
     } else {
       AddProperty(property_id, CSSPropertyID::kInvalid, *variable, important,
                   IsImplicitProperty::kNotImplicit, *parsed_properties_);
@@ -266,8 +268,8 @@ bool CSSPropertyParser::ConsumeCSSWideKeyword(CSSPropertyID unresolved_property,
     AddProperty(property, CSSPropertyID::kInvalid, *value, important,
                 IsImplicitProperty::kNotImplicit, *parsed_properties_);
   } else {
-    AddExpandedPropertyForValue(property, *value, important,
-                                *parsed_properties_);
+    css_property_parser_helpers::AddExpandedPropertyForValue(
+        property, *value, important, *parsed_properties_);
   }
   range_ = range_copy;
   return true;
@@ -285,17 +287,19 @@ static CSSValue* ConsumeSingleViewportDescriptor(
     case CSSPropertyID::kMaxHeight:
       if (id == CSSValueID::kAuto || id == CSSValueID::kInternalExtendToZoom)
         return ConsumeIdent(range);
-      return ConsumeLengthOrPercent(range, css_parser_mode,
-                                    kValueRangeNonNegative);
+      return css_property_parser_helpers::ConsumeLengthOrPercent(
+          range, css_parser_mode, kValueRangeNonNegative);
     case CSSPropertyID::kMinZoom:
     case CSSPropertyID::kMaxZoom:
     case CSSPropertyID::kZoom: {
       if (id == CSSValueID::kAuto)
         return ConsumeIdent(range);
-      CSSValue* parsed_value = ConsumeNumber(range, kValueRangeNonNegative);
+      CSSValue* parsed_value = css_property_parser_helpers::ConsumeNumber(
+          range, kValueRangeNonNegative);
       if (parsed_value)
         return parsed_value;
-      return ConsumePercent(range, kValueRangeNonNegative);
+      return css_property_parser_helpers::ConsumePercent(
+          range, kValueRangeNonNegative);
     }
     case CSSPropertyID::kUserZoom:
       return ConsumeIdent<CSSValueID::kZoom, CSSValueID::kFixed>(range);