Add null check to animations for registered custom property initial values

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

 // Copyright 2016 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/animation/CSSInterpolationType.h"
 
 #include "core/StylePropertyShorthand.h"
 #include "core/animation/StringKeyframe.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSValue.h"
@@ skipping 69 matching lines @@
         m_initialValue(initialValue) {}
 
   bool isValid(const InterpolationEnvironment& environment,
                const InterpolationValue&) const final {
     const CSSValue* inheritedValue =
         environment.state().parentStyle()->getRegisteredVariable(
             m_name, m_isInheritedProperty);
     if (!inheritedValue) {
       inheritedValue = m_initialValue.get();
     }
+    if (inheritedValue == m_inheritedValue.get()) {
+      return true;
+    }
+    if (!inheritedValue || !m_inheritedValue) {
+      return false;
+    }
     return m_inheritedValue->equals(*inheritedValue);
   }
 
   const AtomicString& m_name;
   const bool m_isInheritedProperty;
   Persistent<const CSSValue> m_inheritedValue;
   Persistent<const CSSValue> m_initialValue;
 };
 
 CSSInterpolationType::CSSInterpolationType(PropertyHandle property)
@@ skipping 100 matching lines @@
     // Unregistered custom properties inherit:
     // https://www.w3.org/TR/css-variables-1/#defining-variables
     bool isInheritedProperty = registration ? registration->inherits() : true;
     DCHECK(declaration.isInitial(isInheritedProperty) ||
            declaration.isInherit(isInheritedProperty));
 
     if (!registration) {
       return nullptr;
     }
 
+    const CSSValue* value = nullptr;
     if (declaration.isInitial(isInheritedProperty)) {
-      return maybeConvertValue(*registration->initial(), state,
-                               conversionCheckers);
+      value = registration->initial();
+    } else {
+      value =
+          state.parentStyle()->getRegisteredVariable(name, isInheritedProperty);
+      if (!value) {
+        value = registration->initial();
+      }
+      conversionCheckers.push_back(InheritedCustomPropertyChecker::create(
+          name, isInheritedProperty, value, registration->initial()));
+    }
+    if (!value) {
+      return nullptr;
     }
 
-    DCHECK(declaration.isInherit(isInheritedProperty));
-    const CSSValue* inheritedValue =
-        state.parentStyle()->getRegisteredVariable(name, isInheritedProperty);
-    if (!inheritedValue) {
-      inheritedValue = registration->initial();
-    }
-    conversionCheckers.push_back(InheritedCustomPropertyChecker::create(
-        name, isInheritedProperty, inheritedValue, registration->initial()));
-    return maybeConvertValue(*inheritedValue, state, conversionCheckers);
+    return maybeConvertValue(*value, state, conversionCheckers);
   }
 
   if (declaration.value()->needsVariableResolution()) {
     // TODO(alancutter): Support smooth interpolation with var() values for
     // registered custom properties. This requires integrating animated custom
     // property value application with the CSSVariableResolver to apply them in
     // the appropriate order defined by the chain of var() dependencies.
     // All CSSInterpolationTypes should fail convertion here except for
     // CSSValueInterpolationType.
     return nullptr;
@@ skipping 22 matching lines @@
   const PropertyRegistry::Registration* registration =
       getRegistration(state, name);
   if (!registration) {
     return nullptr;
   }
   const CSSValue* underlyingValue =
       state.style()->getRegisteredVariable(name, registration->inherits());
   if (!underlyingValue) {
     underlyingValue = registration->initial();
   }
+  if (!underlyingValue) {
+    return nullptr;
+  }
   // TODO(alancutter): Remove the need for passing in conversion checkers.
   ConversionCheckers dummyConversionCheckers;
   return maybeConvertValue(*underlyingValue, environment.state(),
                            dummyConversionCheckers);
 }
 
 void CSSInterpolationType::apply(
     const InterpolableValue& interpolableValue,
     const NonInterpolableValue* nonInterpolableValue,
     InterpolationEnvironment& environment) const {
@@ skipping 35 matching lines @@
   if (registration->inherits()) {
     style.setResolvedInheritedVariable(propertyName, variableData.release(),
                                        cssValue);
   } else {
     style.setResolvedNonInheritedVariable(propertyName, variableData.release(),
                                           cssValue);
   }
 }
 
 }  // namespace blink