Added null safety to CSSParserContext args in CSSPropertyOffsetPathUtils

third_party/WebKit/Source/core/css/properties/CSSPropertyOffsetPathUtils.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/CSSPropertyOffsetPathUtils.h"
 
 #include "core/css/CSSIdentifierValue.h"
 #include "core/css/CSSPathValue.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSRayValue.h"
@@ skipping 27 matching lines @@
     return nullptr;
   }
 
   range = function_range;
   if (byte_stream->IsEmpty())
     return CSSIdentifierValue::Create(CSSValueNone);
   return CSSPathValue::Create(std::move(byte_stream));
 }
 
 CSSValue* ConsumeRay(CSSParserTokenRange& range,
-                     const CSSParserContext* context) {
+                     const CSSParserContext& context) {
   DCHECK_EQ(range.Peek().FunctionId(), CSSValueRay);
   CSSParserTokenRange function_range = range;
   CSSParserTokenRange function_args =
       CSSPropertyParserHelpers::ConsumeFunction(function_range);
 
   CSSPrimitiveValue* angle = nullptr;
   CSSIdentifierValue* size = nullptr;
   CSSIdentifierValue* contain = nullptr;
   while (!function_args.AtEnd()) {
     if (!angle) {
       angle = CSSPropertyParserHelpers::ConsumeAngle(
-          function_args, *context, WTF::Optional<UseCounter::Feature>());
+          function_args, context, WTF::Optional<UseCounter::Feature>());
       if (angle)
         continue;
     }
     if (!size) {
       size = CSSPropertyParserHelpers::ConsumeIdent<
           CSSValueClosestSide, CSSValueClosestCorner, CSSValueFarthestSide,
           CSSValueFarthestCorner, CSSValueSides>(function_args);
       if (size)
         continue;
     }
     if (RuntimeEnabledFeatures::cssOffsetPathRayContainEnabled() && !contain) {
       contain = CSSPropertyParserHelpers::ConsumeIdent<CSSValueContain>(
           function_args);
       if (contain)
         continue;
     }
     return nullptr;
   }
   if (!angle || !size)
     return nullptr;
   range = function_range;
   return CSSRayValue::Create(*angle, *size, contain);
 }
 
 }  // namespace
 
 CSSValue* CSSPropertyOffsetPathUtils::ConsumeOffsetPath(
     CSSParserTokenRange& range,
-    const CSSParserContext* context) {
+    const CSSParserContext& context) {
   CSSValue* value = nullptr;
   if (RuntimeEnabledFeatures::cssOffsetPathRayEnabled() &&
       range.Peek().FunctionId() == CSSValueRay)
     value = ConsumeRay(range, context);
   else
     value = ConsumePathOrNone(range);
 
   // Count when we receive a valid path other than 'none'.
   if (value && !value->IsIdentifierValue())
-    context->Count(UseCounter::kCSSOffsetInEffect);
+    context.Count(UseCounter::kCSSOffsetInEffect);
   return value;
 }
 
 CSSValue* CSSPropertyOffsetPathUtils::ConsumePathOrNone(
     CSSParserTokenRange& range) {
   CSSValueID id = range.Peek().Id();
   if (id == CSSValueNone)
     return CSSPropertyParserHelpers::ConsumeIdent(range);
 
   return ConsumePath(range);
 }
 
 }  // namespace blink