DevTools: [regression] compare canonical text when matching styles.

Source/core/inspector/InspectorStyleSheet.cpp

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 581 matching lines @@
     }
 
     for (int i = 0; i < n; ++i) {
         delete [] diff[i];
         delete [] backtrack[i];
     }
     delete [] diff;
     delete [] backtrack;
 }
 
+String canonicalCSSText(RefPtrWillBeRawPtr<CSSRule> rule)
+{
+    if (rule->type() != CSSRule::STYLE_RULE)
+        return rule->cssText();
+    RefPtr<CSSStyleRule> styleRule = toCSSStyleRule(rule.get());
+
+    Vector<String> propertyNames;
+    HashSet<String> propertyNameSet;
+    CSSStyleDeclaration* style = styleRule->style();
+    for (unsigned i = 0; i < style->length(); ++i) {
+        String name = style->item(i);
+        String shorthand = style->getPropertyShorthand(name);
+        if (!shorthand.isEmpty())
+            name = shorthand;
+        if (propertyNameSet.contains(name))
+            continue;
+        propertyNames.append(name);
+        propertyNameSet.add(name);
+    }
+    std::sort(propertyNames.begin(), propertyNames.end(), WTF::codePointCompareLessThan);
+
+    StringBuilder builder;
+    builder.append(styleRule->selectorText());
+    builder.append("{");
+    for (unsigned i = 0; i < propertyNames.size(); ++i) {
+        String name = propertyNames.at(i);
+        builder.append(" ");
+        builder.append(name);
+        builder.append(":");
+        builder.append(style->getPropertyValue(name));
+        if (!style->getPropertyPriority(name).isEmpty()) {
+            builder.append(" ");
+            builder.append(style->getPropertyPriority(name));
+        }
+        builder.append(";");
+    }
+    builder.append("}");
+
+    return builder.toString();
+}
+
 } // namespace
 
 namespace blink {
 
 enum MediaListSource {
     MediaListSourceLinkedSheet,
     MediaListSourceInlineSheet,
     MediaListSourceMediaRule,
     MediaListSourceImportRule
 };
@@ skipping 862 matching lines @@
     if (index == kNotFound)
         return nullptr;
     IndexMap::iterator it = m_sourceDataToRule.find(index);
     if (it == m_sourceDataToRule.end())
         return nullptr;
 
     ASSERT(it->value < m_cssomFlatRules.size());
 
     // Check that CSSOM did not mutate this rule.
     RefPtrWillBeRawPtr<CSSRule> result = m_cssomFlatRules.at(it->value);
-    if (m_parsedFlatRules.at(index)->cssText() != result->cssText())
+    if (canonicalCSSText(m_parsedFlatRules.at(index)) != canonicalCSSText(result))
         return nullptr;
     return result;
 }
 
 RefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyleSheet::sourceDataForRule(RefPtrWillBeRawPtr<CSSRule> rule)
 {
     if (!m_sourceData || !rule)
         return nullptr;
 
     remapSourceDataToCSSOMIfNecessary();
 
     size_t index = m_cssomFlatRules.find(rule.get());
     if (index == kNotFound)
         return nullptr;
     IndexMap::iterator it = m_ruleToSourceData.find(index);
     if (it == m_ruleToSourceData.end())
         return nullptr;
 
     ASSERT(it->value < m_sourceData->size());
 
     // Check that CSSOM did not mutate this rule.
     RefPtrWillBeRawPtr<CSSRule> parsedRule = m_parsedFlatRules.at(it->value);
-    if (rule->cssText() != parsedRule->cssText())
+    if (canonicalCSSText(rule) != canonicalCSSText(parsedRule))
         return nullptr;
 
     return m_sourceData->at(it->value);
 }
 
 void InspectorStyleSheet::remapSourceDataToCSSOMIfNecessary()
 {
     CSSRuleVector cssomRules;
     collectFlatRules(m_pageStyleSheet.get(), &cssomRules);
 
@@ skipping 20 matching lines @@
     collectFlatRules(m_pageStyleSheet.get(), &cssomRules);
 
     if (!m_sourceData)
         return;
 
     CSSRuleVector& parsedRules = m_parsedFlatRules;
 
     Vector<String> cssomRulesText = Vector<String>();
     Vector<String> parsedRulesText = Vector<String>();
     for (size_t i = 0; i < cssomRules.size(); ++i)
-        cssomRulesText.append(cssomRules.at(i)->cssText());
+        cssomRulesText.append(canonicalCSSText(cssomRules.at(i)));
     for (size_t j = 0; j < parsedRules.size(); ++j)
-        parsedRulesText.append(parsedRules.at(j)->cssText());
+        parsedRulesText.append(canonicalCSSText(parsedRules.at(j)));
 
     diff(cssomRulesText, parsedRulesText, &m_ruleToSourceData, &m_sourceDataToRule);
 }
 
 const CSSRuleVector& InspectorStyleSheet::flatRules()
 {
     remapSourceDataToCSSOMIfNecessary();
     return m_cssomFlatRules;
 }
 
@@ skipping 107 matching lines @@
 }
 
 DEFINE_TRACE(InspectorStyleSheetForInlineStyle)
 {
     visitor->trace(m_element);
     visitor->trace(m_inspectorStyle);
     InspectorStyleSheetBase::trace(visitor);
 }
 
 } // namespace blink