Use const CSSParserContext reference at some places where it's never null

Change-Id: I1deab83b451783a6db930a1c6b98055bba57d8f1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2055684Reviewed-by: Anders Hartvoll Ruud <andruud@chromium.org>
Commit-Queue: Xiaocheng Hu <xiaochengh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#741471}

third_party/blink/renderer/core/css/css_syntax_definition.cc

@@ -40,11 +40,9 @@ bool CouldConsumeReservedKeyword(CSSParserTokenRange range) {
   return false;
 }
 
-// TODO(xiaochengh): |context| is never nullptr in this function. Change
-// parameter type to |const CSSParserContext&| to avoid confusion.
 const CSSValue* ConsumeSingleType(const CSSSyntaxComponent& syntax,
                                   CSSParserTokenRange& range,
-                                  const CSSParserContext* context) {
+                                  const CSSParserContext& context) {
   switch (syntax.GetType()) {
     case CSSSyntaxType::kIdent:
       if (range.Peek().GetType() == kIdentToken &&
@@ -55,54 +53,53 @@ const CSSValue* ConsumeSingleType(const CSSSyntaxComponent& syntax,
       }
       return nullptr;
     case CSSSyntaxType::kLength: {
-      CSSParserContext::ParserModeOverridingScope scope(*context,
+      CSSParserContext::ParserModeOverridingScope scope(context,
                                                         kHTMLStandardMode);
       return css_property_parser_helpers::ConsumeLength(
-          range, *context, ValueRange::kValueRangeAll);
+          range, context, ValueRange::kValueRangeAll);
     }
     case CSSSyntaxType::kNumber:
       return css_property_parser_helpers::ConsumeNumber(
-          range, *context, ValueRange::kValueRangeAll);
+          range, context, ValueRange::kValueRangeAll);
     case CSSSyntaxType::kPercentage:
       return css_property_parser_helpers::ConsumePercent(
-          range, *context, ValueRange::kValueRangeAll);
+          range, context, ValueRange::kValueRangeAll);
     case CSSSyntaxType::kLengthPercentage: {
-      CSSParserContext::ParserModeOverridingScope scope(*context,
+      CSSParserContext::ParserModeOverridingScope scope(context,
                                                         kHTMLStandardMode);
       return css_property_parser_helpers::ConsumeLengthOrPercent(
-          range, *context, ValueRange::kValueRangeAll);
+          range, context, ValueRange::kValueRangeAll);
     }
     case CSSSyntaxType::kColor: {
-      CSSParserContext::ParserModeOverridingScope scope(*context,
+      CSSParserContext::ParserModeOverridingScope scope(context,
                                                         kHTMLStandardMode);
-      return css_property_parser_helpers::ConsumeColor(range, *context);
+      return css_property_parser_helpers::ConsumeColor(range, context);
     }
     case CSSSyntaxType::kImage:
-      return css_property_parser_helpers::ConsumeImage(range, *context);
+      return css_property_parser_helpers::ConsumeImage(range, context);
     case CSSSyntaxType::kUrl:
-      return css_property_parser_helpers::ConsumeUrl(range, *context);
+      return css_property_parser_helpers::ConsumeUrl(range, context);
     case CSSSyntaxType::kInteger:
       return css_property_parser_helpers::ConsumeIntegerOrNumberCalc(range,
-                                                                     *context);
+                                                                     context);
     case CSSSyntaxType::kAngle:
       return css_property_parser_helpers::ConsumeAngle(
-          range, *context, base::Optional<WebFeature>());
+          range, context, base::Optional<WebFeature>());
     case CSSSyntaxType::kTime:
       return css_property_parser_helpers::ConsumeTime(
-          range, *context, ValueRange::kValueRangeAll);
+          range, context, ValueRange::kValueRangeAll);
     case CSSSyntaxType::kResolution:
       return css_property_parser_helpers::ConsumeResolution(range);
     case CSSSyntaxType::kTransformFunction:
-      return css_property_parser_helpers::ConsumeTransformValue(range,
-                                                                *context);
+      return css_property_parser_helpers::ConsumeTransformValue(range, context);
     case CSSSyntaxType::kTransformList:
-      return css_property_parser_helpers::ConsumeTransformList(range, *context);
+      return css_property_parser_helpers::ConsumeTransformList(range, context);
     case CSSSyntaxType::kCustomIdent:
       // TODO(crbug.com/579788): Implement 'revert'.
       // TODO(crbug.com/882285): Make 'default' invalid as <custom-ident>.
       if (IsReservedIdentToken(range.Peek()))
         return nullptr;
-      return css_property_parser_helpers::ConsumeCustomIdent(range, *context);
+      return css_property_parser_helpers::ConsumeCustomIdent(range, context);
     default:
       NOTREACHED();
       return nullptr;
@@ -111,7 +108,7 @@ const CSSValue* ConsumeSingleType(const CSSSyntaxComponent& syntax,
 
 const CSSValue* ConsumeSyntaxComponent(const CSSSyntaxComponent& syntax,
                                        CSSParserTokenRange range,
-                                       const CSSParserContext* context) {
+                                       const CSSParserContext& context) {
   // CSS-wide keywords are already handled by the CSSPropertyParser
   if (syntax.GetRepeat() == CSSSyntaxRepeat::kSpaceSeparated) {
     CSSValueList* list = CSSValueList::CreateSpaceSeparated();
@@ -143,7 +140,7 @@ const CSSValue* ConsumeSyntaxComponent(const CSSSyntaxComponent& syntax,
 }  // namespace
 
 const CSSValue* CSSSyntaxDefinition::Parse(CSSParserTokenRange range,
-                                           const CSSParserContext* context,
+                                           const CSSParserContext& context,
                                            bool is_animation_tainted) const {
   if (IsTokenStream()) {
     // TODO(crbug.com/579788): Implement 'revert'.
@@ -151,7 +148,7 @@ const CSSValue* CSSSyntaxDefinition::Parse(CSSParserTokenRange range,
     if (CouldConsumeReservedKeyword(range))
       return nullptr;
     return CSSVariableParser::ParseRegisteredPropertyValue(
-        range, *context, false, is_animation_tainted);
+        range, context, false, is_animation_tainted);
   }
   range.ConsumeWhitespace();
   for (const CSSSyntaxComponent& component : syntax_components_) {
@@ -159,7 +156,7 @@ const CSSValue* CSSSyntaxDefinition::Parse(CSSParserTokenRange range,
             ConsumeSyntaxComponent(component, range, context))
       return result;
   }
-  return CSSVariableParser::ParseRegisteredPropertyValue(range, *context, true,
+  return CSSVariableParser::ParseRegisteredPropertyValue(range, context, true,
                                                          is_animation_tainted);
 }
 

third_party/blink/renderer/core/css/css_syntax_definition.h

@@ -17,7 +17,7 @@ class CSSValue;
 class CORE_EXPORT CSSSyntaxDefinition {
  public:
   const CSSValue* Parse(CSSParserTokenRange,
-                        const CSSParserContext*,
+                        const CSSParserContext&,
                         bool is_animation_tainted) const;
   bool IsTokenStream() const {
     return syntax_components_.size() == 1 &&

third_party/blink/renderer/core/css/css_variable_data.cc

@@ -96,7 +96,8 @@ const CSSValue* CSSVariableData::ParseForSyntax(
   DCHECK(!NeedsVariableResolution());
   // TODO(timloh): This probably needs a proper parser context for
   // relative URL resolution.
-  return syntax.Parse(TokenRange(), StrictCSSParserContext(secure_context_mode),
+  return syntax.Parse(TokenRange(),
+                      *StrictCSSParserContext(secure_context_mode),
                       is_animation_tainted_);
 }
 

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

@@ -190,6 +190,8 @@ bool CSSParserContext::operator==(const CSSParserContext& other) const {
          resource_fetch_restriction_ == other.resource_fetch_restriction_;
 }
 
+// TODO(xiaochengh): This function never returns null. Change it to return a
+// const reference to avoid confusion.
 const CSSParserContext* StrictCSSParserContext(
     SecureContextMode secure_context_mode) {
   DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadSpecific<Persistent<CSSParserContext>>,

third_party/blink/renderer/core/css/properties/longhands/custom_property.cc

@@ -188,7 +188,7 @@ const CSSValue* CustomProperty::ParseTyped(
     const CSSParserLocalContext& local_context) const {
   if (!registration_)
     return ParseUntyped(range, context, local_context);
-  return registration_->Syntax().Parse(range, &context,
+  return registration_->Syntax().Parse(range, context,
                                        local_context.IsAnimationTainted());
 }
 

third_party/blink/renderer/core/css/property_registration.cc

@@ -133,8 +133,8 @@ PropertyRegistration* PropertyRegistration::MaybeCreate(
     const CSSParserContext* parser_context =
         document.ElementSheet().Contents()->ParserContext();
     const bool is_animation_tainted = false;
-    initial = syntax->Parse(initial_variable_data->TokenRange(), parser_context,
-                            is_animation_tainted);
+    initial = syntax->Parse(initial_variable_data->TokenRange(),
+                            *parser_context, is_animation_tainted);
     if (!initial)
       return nullptr;
     if (!ComputationallyIndependent(*initial))
@@ -195,7 +195,7 @@ void PropertyRegistration::registerProperty(
     const auto tokens = tokenizer.TokenizeToEOF();
     bool is_animation_tainted = false;
     initial = syntax_definition->Parse(CSSParserTokenRange(tokens),
-                                       parser_context, is_animation_tainted);
+                                       *parser_context, is_animation_tainted);
     if (!initial) {
       exception_state.ThrowDOMException(
           DOMExceptionCode::kSyntaxError,

third_party/blink/renderer/core/css/resolver/css_variable_resolver.cc

@@ -52,7 +52,7 @@ CSSVariableResolver::Fallback CSSVariableResolver::ResolveFallback(
     const CSSParserContext* context =
         StrictCSSParserContext(state_.GetDocument().GetSecureContextMode());
     const bool is_animation_tainted = false;
-    if (!registration->Syntax().Parse(resolved_range, context,
+    if (!registration->Syntax().Parse(resolved_range, *context,
                                       is_animation_tainted))
       return Fallback::kFail;
   }

third_party/blink/renderer/core/css/resolver/css_variable_resolver_test.cc

@@ -301,7 +301,7 @@ TEST_F(CSSVariableResolverTest, NeedsResolutionClearedByResolver) {
   const auto tokens = CSSTokenizer(initial_value_str).TokenizeToEOF();
   const auto* context = MakeGarbageCollected<CSSParserContext>(GetDocument());
   const CSSValue* initial_value =
-      token_syntax->Parse(CSSParserTokenRange(tokens), context, false);
+      token_syntax->Parse(CSSParserTokenRange(tokens), *context, false);
   ASSERT_TRUE(initial_value);
   ASSERT_TRUE(initial_value->IsVariableReferenceValue());
   PropertyRegistration* registration =

third_party/blink/renderer/core/css/style_sheet_contents.h

@@ -59,6 +59,8 @@ class CORE_EXPORT StyleSheetContents final
   StyleSheetContents() = delete;
   ~StyleSheetContents();
 
+  // TODO(xiaochengh): |parser_context_| should never be null. Make it return a
+  // const reference here to avoid confusion.
   const CSSParserContext* ParserContext() const { return parser_context_; }
 
   const AtomicString& DefaultNamespace() const { return default_namespace_; }