Devtools [LayoutEditor]: Patch values in the selected rule

Source/core/inspector/InspectorCSSAgent.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 76 matching lines @@
     CSSParser::parseSheet(CSSParserContext(*document, 0), styleSheetContents.get(), text);
 
     RefPtrWillBeRawPtr<CSSStyleSheet> styleSheet = CSSStyleSheet::create(styleSheetContents);
     CSSStyleRule* rule = toCSSStyleRule(styleSheet->item(0));
     CSSStyleDeclaration* style = rule->style();
     TrackExceptionState exceptionState;
     style->setProperty(longhand, newValue, style->getPropertyPriority(longhand), exceptionState);
     return style->getPropertyValue(shorthand);
 }
 
+PassRefPtrWillBeRawPtr<CSSRuleList> filterDuplicateRules(RefPtrWillBeRawPtr<CSSRuleList> ruleList)
+{
+    if (!ruleList)
+        return nullptr;
+
+    HashSet<CSSStyleRule*> uniqRulesSet;
+    RefPtrWillBeRawPtr<StaticCSSRuleList> uniqRules = StaticCSSRuleList::create();
+    for (unsigned i = ruleList->length(); i > 0; --i) {
+        CSSRule* rule = ruleList->item(i - 1);
+        if (!rule || rule->type() != CSSRule::STYLE_RULE)
+            continue;
+
+        CSSStyleRule* styleRule = toCSSStyleRule(rule);
+        if (uniqRulesSet.contains(styleRule))
+            continue;
+        uniqRulesSet.add(styleRule);
+        uniqRules->rules().prepend(styleRule);

[dgozman, 2015/09/03 23:04:20]

Drop the n^2.

+    }
+    return uniqRules.release();
+}
+
 } // namespace
 
 namespace CSSAgentState {
 static const char cssAgentEnabled[] = "cssAgentEnabled";
 }
 
 typedef blink::InspectorBackendDispatcher::CSSCommandHandler::EnableCallback EnableCallback;
 
 namespace blink {
 
@@ skipping 1279 matching lines @@
     // We should come up with a solution for matching pseudo-element selectors against ordinary Elements, too.
     return selectorPseudoId == elementPseudoId;
 }
 
 PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::RuleMatch> > InspectorCSSAgent::buildArrayForMatchedRuleList(CSSRuleList* ruleList, Element* element, PseudoId matchesForPseudoId)
 {
     RefPtr<TypeBuilder::Array<TypeBuilder::CSS::RuleMatch> > result = TypeBuilder::Array<TypeBuilder::CSS::RuleMatch>::create();
     if (!ruleList)
         return result.release();
 
-    HashSet<CSSStyleRule*> uniqRulesSet;
-    Vector<CSSStyleRule*> uniqRules;
-    for (unsigned i = ruleList->length(); i > 0; --i) {
-        CSSStyleRule* rule = asCSSStyleRule(ruleList->item(i - 1));
-        if (uniqRulesSet.contains(rule))
-            continue;
-        uniqRulesSet.add(rule);
-        uniqRules.append(rule);
-    }
+    RefPtrWillBeRawPtr<CSSRuleList> uniqRules = filterDuplicateRules(ruleList);
 
-    for (unsigned i = uniqRules.size(); i > 0; --i) {
-        CSSStyleRule* rule = uniqRules.at(i - 1);
+    for (unsigned i = uniqRules->length(); i > 0; --i) {
+        CSSStyleRule* rule = asCSSStyleRule(uniqRules->item(i - 1));
         RefPtr<TypeBuilder::CSS::CSSRule> ruleObject = buildObjectForRule(rule);
         if (!ruleObject)
             continue;
         RefPtr<TypeBuilder::Array<int> > matchingSelectors = TypeBuilder::Array<int>::create();
         const CSSSelectorList& selectorList = rule->styleRule()->selectorList();
         long index = 0;
         PseudoId elementPseudoId = matchesForPseudoId ? matchesForPseudoId : element->pseudoId();
         for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(*selector)) {
             const CSSSelector* firstTagHistorySelector = selector;
             bool matched = false;
@@ skipping 90 matching lines @@
         Element* element = toElement(m_domAgent->nodeForId(state.key));
         if (element && element->ownerDocument())
             documentsToChange.add(element->ownerDocument());
     }
 
     m_nodeIdToForcedPseudoState.clear();
     for (auto& document : documentsToChange)
         document->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::Inspector));
 }
 
-PassRefPtrWillBeRawPtr<CSSStyleDeclaration> InspectorCSSAgent::findEffectiveDeclaration(Element* element, CSSPropertyID propertyId)
+PassRefPtrWillBeRawPtr<CSSRuleList> InspectorCSSAgent::matchedRulesList(Element* element)
 {
     PseudoId elementPseudoId = element->pseudoId();
-    CSSStyleDeclaration* inlineStyle =  element->style();
-
     if (elementPseudoId) {
         element = element->parentOrShadowHostElement();
         if (!element)
             return nullptr;
     }
 
     Document* ownerDocument = element->ownerDocument();
     // A non-active document has no styles.
     if (!ownerDocument->isActive())
         return nullptr;
 
+    StyleResolver& styleResolver = ownerDocument->ensureStyleResolver();
+    element->updateDistribution();
+    return filterDuplicateRules(styleResolver.pseudoCSSRulesForElement(element, elementPseudoId, StyleResolver::AllCSSRules));
+}
+
+PassRefPtrWillBeRawPtr<CSSStyleDeclaration> InspectorCSSAgent::findEffectiveDeclaration(CSSPropertyID propertyId, CSSRuleList* ruleList, CSSStyleDeclaration* inlineStyle)
+{
+    if (!ruleList && !inlineStyle)
+        return nullptr;
+
     String longhand = getPropertyNameString(propertyId);
-
     RefPtrWillBeRawPtr<CSSStyleDeclaration> foundStyle = nullptr;
     bool isImportant = false;
 
     if (inlineStyle && !inlineStyle->getPropertyValue(longhand).isEmpty()) {
         foundStyle = inlineStyle;
         isImportant = inlineStyle->getPropertyPriority(longhand) == "important";
     }
 
-    StyleResolver& styleResolver = ownerDocument->ensureStyleResolver();
-    element->updateDistribution();
-    RefPtrWillBeRawPtr<CSSRuleList> ruleList = styleResolver.pseudoCSSRulesForElement(element, elementPseudoId, StyleResolver::AllCSSRules);
-
     for (unsigned i = 0, size = ruleList ? ruleList->length() : 0; i < size; ++i) {
         if (isImportant)
             break;
 
         if (ruleList->item(size - i - 1)->type() != CSSRule::STYLE_RULE)
             continue;
 
         CSSStyleRule* rule = toCSSStyleRule(ruleList->item(size - i - 1));
         if (!rule)
             continue;
 
         CSSStyleDeclaration* style = rule->style();
         if (!style)
             continue;
 
         if (style->getPropertyValue(longhand).isEmpty())
             continue;
 
         isImportant = style->getPropertyPriority(longhand) == "important";
         if (isImportant || !foundStyle)
             foundStyle = style;
     }
 
     return foundStyle.release();
 }
 
-void InspectorCSSAgent::setCSSPropertyValue(ErrorString* errorString, Element* element, CSSPropertyID propertyId, const String& value)
+void InspectorCSSAgent::setCSSPropertyValue(ErrorString* errorString, Element* element, RefPtrWillBeRawPtr<CSSStyleDeclaration> style, CSSPropertyID propertyId, const String& value, bool forceImportant)
 {
-    Document* ownerDocument = element->ownerDocument();
-    if (!ownerDocument->isActive()) {
-        *errorString = "Can't edit a node from a non-active document";
-        return;
-    }
-
-    Vector<StylePropertyShorthand, 4> shorthands;
-    getMatchingShorthandsForLonghand(propertyId, &shorthands);
-
-    String shorthand =  shorthands.size() > 0 ? getPropertyNameString(shorthands[0].id()) : String();
-    String longhand = getPropertyNameString(propertyId);
-
-    RefPtrWillBeRawPtr<CSSStyleDeclaration> foundStyle = findEffectiveDeclaration(element, propertyId);
-    CSSStyleDeclaration* inlineStyle =  element->style();
-    if (!foundStyle || !foundStyle->parentStyleSheet())
-        foundStyle = inlineStyle;
-
-    if (!foundStyle) {
-        *errorString = "Can't find a style to edit";
-        return;
-    }
-
     InspectorStyleSheetBase* inspectorStyleSheet =  nullptr;
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = nullptr;
-    if (foundStyle != inlineStyle) {
-        InspectorStyleSheet* styleSheet =  bindStyleSheet(foundStyle->parentStyleSheet());
+    // An absence of the parent rule means that given style is an inline style.
+    if (style->parentRule()) {
+        InspectorStyleSheet* styleSheet = bindStyleSheet(style->parentStyleSheet());
         inspectorStyleSheet = styleSheet;
-        sourceData = styleSheet->sourceDataForRule(foundStyle->parentRule());
-    }
-
-    if (!sourceData) {
+        sourceData = styleSheet->sourceDataForRule(style->parentRule());
+    } else {
         InspectorStyleSheetForInlineStyle* inlineStyleSheet = asInspectorStyleSheet(element);
         inspectorStyleSheet = inlineStyleSheet;
         sourceData = inlineStyleSheet->ruleSourceData();
     }
 
     if (!sourceData) {
         *errorString = "Can't find a source to edit";
         return;
     }
 
+    Vector<StylePropertyShorthand, 4> shorthands;
+    getMatchingShorthandsForLonghand(propertyId, &shorthands);
+
+    String shorthand =  shorthands.size() > 0 ? getPropertyNameString(shorthands[0].id()) : String();
+    String longhand = getPropertyNameString(propertyId);
+
     int foundIndex = -1;
     WillBeHeapVector<CSSPropertySourceData> properties = sourceData->styleSourceData->propertyData;
     for (unsigned i = 0; i < properties.size(); ++i) {
         CSSPropertySourceData property = properties[properties.size() - i - 1];
         String name = property.name;
         if (property.disabled)
             continue;
 
         if (name != shorthand && name != longhand)
             continue;
 
         if (property.important || foundIndex == -1)
             foundIndex = properties.size() - i - 1;
 
         if (property.important)
             break;
     }
 
     SourceRange bodyRange = sourceData->ruleBodyRange;
     String styleSheetText;
     inspectorStyleSheet->getText(&styleSheetText);
     String styleText = styleSheetText.substring(bodyRange.start, bodyRange.length());
     SourceRange changeRange;
     if (foundIndex == -1) {
-        bool isImportant = inlineStyle->getPropertyPriority(longhand) == "important";
-        String newPropertyText = "\n" + longhand + ": " + value + (isImportant ? " !important" : "") + ";";
+        String newPropertyText = "\n" + longhand + ": " + value + (forceImportant ? " !important" : "") + ";";
         if (!styleText.isEmpty() && !styleText.stripWhiteSpace().endsWith(';'))
             newPropertyText = ";" + newPropertyText;
         styleText.append(newPropertyText);
         changeRange.start = bodyRange.end;
         changeRange.end = bodyRange.end + newPropertyText.length();
     } else {
         CSSPropertySourceData declaration = properties[foundIndex];
         String newValueText;
         if (declaration.name == shorthand)
-            newValueText = createShorthandValue(ownerDocument, shorthand, declaration.value, longhand, value);
+            newValueText = createShorthandValue(element->ownerDocument(), shorthand, declaration.value, longhand, value);
         else
             newValueText = value;
 
-        String newPropertyText = declaration.name + ": " + newValueText + (declaration.important ? " !important" : "") + ";";
+        String newPropertyText = declaration.name + ": " + newValueText + (declaration.important || forceImportant ? " !important" : "") + ";";
         styleText.replace(declaration.range.start - bodyRange.start, declaration.range.length(), newPropertyText);
         changeRange.start = declaration.range.start;
         changeRange.end = changeRange.start + newPropertyText.length();
     }
     CSSStyleDeclaration* resultStyle = setStyleText(errorString, inspectorStyleSheet, bodyRange, styleText);
     if (resultStyle) {
         frontend()->layoutEditorChange(inspectorStyleSheet->id(), inspectorStyleSheet->buildSourceRangeObject(changeRange));
         frontend()->flush();
     }
 }
 
 void InspectorCSSAgent::setEffectivePropertyValueForNode(ErrorString* errorString, int nodeId, const String& propertyName, const String& value)
 {
+    // TODO: move testing from CSSAgent to layout editor.
     Element* element = elementForId(errorString, nodeId);
     if (!element)
         return;
 
     CSSPropertyID property = cssPropertyID(propertyName);
     if (!property) {
         *errorString = "Invalid property name";
         return;
     }
-    setCSSPropertyValue(errorString, element, cssPropertyID(propertyName), value);
+
+    Document* ownerDocument = element->ownerDocument();
+    if (!ownerDocument->isActive()) {
+        *errorString = "Can't edit a node from a non-active document";
+        return;
+    }
+
+    CSSPropertyID propertyId = cssPropertyID(propertyName);
+    CSSStyleDeclaration* inlineStyle = element->style();
+    RefPtrWillBeRawPtr<CSSRuleList> ruleList = matchedRulesList(element);
+    RefPtrWillBeRawPtr<CSSStyleDeclaration> foundStyle = findEffectiveDeclaration(propertyId, ruleList.get(), inlineStyle);
+    if (!foundStyle || !foundStyle->parentStyleSheet())
+        foundStyle = inlineStyle;
+
+    if (!foundStyle) {
+        *errorString = "Can't find a style to edit";
+        return;
+    }
+
+    setCSSPropertyValue(errorString, element, foundStyle.get(), propertyId, value);
 }
 
 DEFINE_TRACE(InspectorCSSAgent)
 {
     visitor->trace(m_domAgent);
     visitor->trace(m_pageAgent);
     visitor->trace(m_resourceAgent);
     visitor->trace(m_resourceContentLoader);
 #if ENABLE(OILPAN)
     visitor->trace(m_idToInspectorStyleSheet);
     visitor->trace(m_idToInspectorStyleSheetForInlineStyle);
     visitor->trace(m_cssStyleSheetToInspectorStyleSheet);
     visitor->trace(m_documentToCSSStyleSheets);
     visitor->trace(m_invalidatedDocuments);
     visitor->trace(m_nodeToInspectorStyleSheet);
     visitor->trace(m_documentToViaInspectorStyleSheet);
 #endif
     visitor->trace(m_inspectorUserAgentStyleSheet);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink