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 1497 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)

[dgozman, 2015/09/02 22:26:16]

Can we kill this function?

[sergeyv, 2015/09/03 00:52:28]

Done.

 {
+    RefPtrWillBeRawPtr<CSSRuleList> ruleList = matchedRulesList(element);
+    return findEffectiveDeclaration(propertyId, ruleList.get(), element->pseudoId() ? nullptr : element->style());

[dgozman, 2015/09/02 22:26:17]

Can we always call element->style()?

[sergeyv, 2015/09/03 00:52:27]

Done.

+}
+
+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 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)

[lushnikov, 2015/09/02 23:00:43]

can we rename? there are 3 setCSSPropertyValue.. methods 

[dgozman, 2015/09/02 23:03:11]

Inline this into it's single usage.

[sergeyv, 2015/09/03 00:52:27]

Done.

 {
     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;
     }
 
+    setCSSPropertyValue(errorString, element, foundStyle.get(), propertyId, value);
+}
+
+void InspectorCSSAgent::setCSSPropertyValue(ErrorString* errorString, Element* element, CSSStyleDeclaration* style, CSSPropertyID propertyId, const String& value, bool forceImportant)
+{
     InspectorStyleSheetBase* inspectorStyleSheet =  nullptr;
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = nullptr;
-    if (foundStyle != inlineStyle) {
-        InspectorStyleSheet* styleSheet =  bindStyleSheet(foundStyle->parentStyleSheet());
+    if (style->parentRule()) {

[dgozman, 2015/09/02 22:26:16]

Let's comment that this means inline style.

[sergeyv, 2015/09/03 00:52:27]

Done.

+        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)
 {
     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);
 }
 
+void InspectorCSSAgent::setCSSPropertyValueInRule(ErrorString* errorString, Element* element, CSSStyleRule* rule, CSSPropertyID propertyId, const String& value)

[dgozman, 2015/09/02 22:26:16]

This one can move to layout editor.

[sergeyv, 2015/09/03 00:52:28]

Done.

+{
+    RefPtrWillBeRawPtr<CSSRuleList> ruleList = matchedRulesList(element);
+    RefPtrWillBeRawPtr<CSSStyleDeclaration> effectiveDeclaration = findEffectiveDeclaration(propertyId, ruleList.get(), element->pseudoId() ? nullptr : element->style());
+
+    CSSStyleRule* effectiveRule = nullptr;
+    if (effectiveDeclaration->parentRule() && effectiveDeclaration->parentRule()->type() == CSSRule::STYLE_RULE)

[lushnikov, 2015/09/02 23:00:43]

effectiveDeclaration &&

[sergeyv, 2015/09/03 00:52:28]

Done.

+        effectiveRule = toCSSStyleRule(effectiveDeclaration->parentRule());
+
+    String longhand = getPropertyNameString(propertyId);
+    bool forceImportant = effectiveDeclaration && effectiveDeclaration->getPropertyPriority(longhand) == "important";
+
+    if (effectiveDeclaration && rule) {
+        int effectiveRuleIndex = -1;
+        int ruleIndex = -1;
+        for (unsigned i = 0, size = ruleList ? ruleList->length() : 0; i < size; ++i) {
+            CSSRule* currentRule = ruleList->item(size - i - 1);
+            if (currentRule == effectiveRule)
+                effectiveRuleIndex = i;
+            if (currentRule == rule)
+                ruleIndex = i;
+        }
+        forceImportant |= effectiveRuleIndex < ruleIndex;
+    }
+
+    setCSSPropertyValue(errorString, element, rule ? rule->style() : element->style(), propertyId, value, forceImportant);
+}
+
 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