Invalidate properties registered as non-inherited for custom paint

third_party/WebKit/Source/core/style/ComputedStyle.cpp

 /*
  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 1000 matching lines @@
     return true;
 
   for (CSSPropertyID propertyID : *value->nativeInvalidationProperties()) {
     // TODO(ikilpatrick): remove isInterpolableProperty check once
     // CSSPropertyEquality::propertiesEqual correctly handles all properties.
     if (!CSSPropertyMetadata::isInterpolableProperty(propertyID) ||
         !CSSPropertyEquality::propertiesEqual(propertyID, *this, other))
       return true;
   }
 
-  if (inheritedVariables() || other.inheritedVariables()) {
+  if (inheritedVariables() || nonInheritedVariables() ||
+      other.inheritedVariables() || other.nonInheritedVariables()) {

[meade_UTC10, 2016/10/19 07:41:14]

There are variables that aren't inherited or non-inherited? It sounds like this
should be run every time if there is a variable at all?

[Timothy Loh, 2016/10/20 06:05:17]

There's just no function right now that checks whether there are any custom
properties set since it's only used for early-out optimisations like this.

     for (const AtomicString& property :
          *value->customInvalidationProperties()) {
-      CSSVariableData* thisVar =
-          inheritedVariables() ? inheritedVariables()->getVariable(property)
-                               : nullptr;
-      CSSVariableData* otherVar =
-          other.inheritedVariables()
-              ? other.inheritedVariables()->getVariable(property)
-              : nullptr;
-
-      if (!dataEquivalent(thisVar, otherVar))
+      if (!dataEquivalent(getVariable(property), other.getVariable(property)))
         return true;
     }
   }
 
   return false;
 }
 
 void ComputedStyle::updatePropertySpecificDifferences(
     const ComputedStyle& other,
     StyleDifference& diff) const {
@@ skipping 730 matching lines @@
 }
 
 void ComputedStyle::removeInheritedVariable(const AtomicString& name) {
   mutableInheritedVariables().removeVariable(name);
 }
 
 void ComputedStyle::removeNonInheritedVariable(const AtomicString& name) {
   mutableNonInheritedVariables().removeVariable(name);
 }
 
+CSSVariableData* ComputedStyle::getVariable(const AtomicString& name) const {
+  if (inheritedVariables()) {
+    if (CSSVariableData* variable = inheritedVariables()->getVariable(name))
+      return variable;
+  }
+  if (nonInheritedVariables()) {
+    if (CSSVariableData* variable = nonInheritedVariables()->getVariable(name))
+      return variable;
+  }
+  return nullptr;
+}
+
 float ComputedStyle::wordSpacing() const {
   return getFontDescription().wordSpacing();
 }
 float ComputedStyle::letterSpacing() const {
   return getFontDescription().letterSpacing();
 }
 
 bool ComputedStyle::setFontDescription(const FontDescription& v) {
   if (m_styleInheritedData->font.getFontDescription() != v) {
     m_styleInheritedData.access()->font = Font(v);
@@ skipping 575 matching lines @@
     if (value < 0)
       fvalue -= 0.5f;
     else
       fvalue += 0.5f;
   }
 
   return roundForImpreciseConversion<int>(fvalue / zoomFactor);
 }
 
 }  // namespace blink