Devtools [LayoutEditor]: Patch values in the selected rule

Source/core/inspector/LayoutEditor.cpp

 // Copyright 2015 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 "config.h"
 #include "core/inspector/LayoutEditor.h"
 
 #include "core/css/CSSComputedStyleDeclaration.h"
 #include "core/css/CSSImportRule.h"
 #include "core/css/CSSMediaRule.h"
@@ skipping 247 matching lines @@
     appendAnchorFor(anchors.get(), "margin", "margin-right", marginHandles.p2(), orthogonals.p2());
     appendAnchorFor(anchors.get(), "margin", "margin-bottom", marginHandles.p3(), orthogonals.p3());
     appendAnchorFor(anchors.get(), "margin", "margin-left", marginHandles.p4(), orthogonals.p4());
 
     object->setArray("anchors", anchors.release());
     return object.release();
 }
 
 RefPtrWillBeRawPtr<CSSPrimitiveValue> LayoutEditor::getPropertyCSSValue(CSSPropertyID property) const
 {
-    RefPtrWillBeRawPtr<CSSStyleDeclaration> style = m_cssAgent->findEffectiveDeclaration(m_element.get(), property);
+    RefPtrWillBeRawPtr<CSSRuleList> ruleList = m_cssAgent->matchedRulesList(m_element.get());
+    RefPtrWillBeRawPtr<CSSStyleDeclaration> style = m_cssAgent->findEffectiveDeclaration(property, ruleList.get(), m_element->style());
     if (!style)
         return nullptr;
 
     RefPtrWillBeRawPtr<CSSValue> cssValue = style->getPropertyCSSValueInternal(property);
     if (!cssValue || !cssValue->isPrimitiveValue())
         return nullptr;
 
     return toCSSPrimitiveValue(cssValue.get());
 }
 
@@ skipping 46 matching lines @@
     default:
         ASSERT_NOT_REACHED();
         break;
     }
     m_propertyInitialValue = cssValue ? cssValue->getFloatValue() : 0;
 }
 
 void LayoutEditor::overlayPropertyChanged(float cssDelta)
 {
     if (m_changingProperty && m_factor) {
-        String errorString;
         float newValue = toValidValue(m_changingProperty, cssDelta / m_factor + m_propertyInitialValue);
-        m_cssAgent->setCSSPropertyValue(&errorString, m_element.get(), m_changingProperty, truncateZeroes(String::format("%.2f", newValue)) + CSSPrimitiveValue::unitTypeToString(m_valueUnitType));
-        if (!errorString)
-            m_isDirty = true;
+        m_isDirty |= setCSSPropertyValueInCurrentRule(truncateZeroes(String::format("%.2f", newValue)) + CSSPrimitiveValue::unitTypeToString(m_valueUnitType));
     }
 }
 
 void LayoutEditor::overlayEndedPropertyChange()
 {
     m_changingProperty = CSSPropertyInvalid;
     m_propertyInitialValue = 0;
     m_factor = 0;
     m_valueUnitType = CSSPrimitiveValue::UnitType::Unknown;
 }
@@ skipping 11 matching lines @@
     m_matchedRules.clear();
     m_cachedSelectorsInfo.clear();
     m_currentRuleIndex = -1;
 }
 
 void LayoutEditor::initializeCSSRules()
 {
     if (!m_element)
         return;
 
-    Document* ownerDocument = m_element->ownerDocument();
-    // A non-active document has no styles.
-    if (!ownerDocument->isActive())
-        return;
-
-    // Matched rules.
-    StyleResolver& styleResolver = ownerDocument->ensureStyleResolver();
-    PseudoId elementPseudoId = m_element->pseudoId();
-    m_element->updateDistribution();
-    RefPtrWillBeRawPtr<CSSRuleList> matchedRules = styleResolver.pseudoCSSRulesForElement(m_element.get(), elementPseudoId, StyleResolver::AllCSSRules);
+    RefPtrWillBeRawPtr<CSSRuleList> matchedRules = m_cssAgent->matchedRulesList(m_element.get());
     if (!matchedRules)
         return;
 
     HashSet<CSSStyleRule*> uniqRulesSet;
     Vector<CSSStyleRule*> uniqRules;
     for (unsigned i = matchedRules->length(); i > 0; --i) {
         CSSRule* rule = matchedRules->item(i);
         if (!rule || rule->type() != CSSRule::STYLE_RULE || !rule->parentStyleSheet())
             continue;
 
         CSSStyleRule* styleRule = toCSSStyleRule(rule);
 
         if (uniqRulesSet.contains(styleRule))
             continue;
         uniqRulesSet.add(styleRule);
         uniqRules.append(styleRule);
     }
     Vector<std::pair<unsigned, CSSStyleRule*>> selectors;
     for (unsigned i = 0; i < uniqRules.size(); ++i) {
         TrackExceptionState exceptionState;
-        RefPtrWillBeRawPtr<StaticElementList> elements = ownerDocument->querySelectorAll(AtomicString(uniqRules[i]->selectorText()), exceptionState);
+        RefPtrWillBeRawPtr<StaticElementList> elements = m_element->ownerDocument()->querySelectorAll(AtomicString(uniqRules[i]->selectorText()), exceptionState);
         unsigned length = exceptionState.hadException() ? 0: elements->length();
         selectors.append(std::make_pair(length, uniqRules[i]));
     }
 
     std::sort(selectors.begin(), selectors.end(), &comparePairs);
     for (size_t i = 0; i < selectors.size(); ++i)
         m_matchedRules.append(selectors[i].second);
 };
 
 void LayoutEditor::nextSelector()
@@ skipping 63 matching lines @@
 
         InspectorHighlight highlight(element, config, false);
         highlights->pushObject(highlight.asJSONObject());
     }
 
     object->setArray("nodes", highlights.release());
     m_cachedSelectorsInfo.add(m_currentRuleIndex, object->toJSONString());
     return m_cachedSelectorsInfo.get(m_currentRuleIndex);
 }
 
+bool LayoutEditor::setCSSPropertyValueInCurrentRule(const String& value)
+{
+    if (!m_element)
+        return false;
+
+    CSSStyleRule* rule = m_currentRuleIndex == -1 ? nullptr : m_matchedRules[m_currentRuleIndex].get();

[dgozman, 2015/09/03 20:42:14]

RefPtrWil....<CSSStyleRule>

[sergeyv, 2015/09/03 22:43:27]

Done.

+    RefPtrWillBeRawPtr<CSSRuleList> ruleList = m_cssAgent->matchedRulesList(m_element.get());
+    RefPtrWillBeRawPtr<CSSStyleDeclaration> effectiveDeclaration = m_cssAgent->findEffectiveDeclaration(m_changingProperty, ruleList.get(), m_element->style());
+
+    CSSStyleRule* effectiveRule = nullptr;
+    if (effectiveDeclaration && effectiveDeclaration->parentRule() && effectiveDeclaration->parentRule()->type() == CSSRule::STYLE_RULE)
+        effectiveRule = toCSSStyleRule(effectiveDeclaration->parentRule());
+
+    String longhand = getPropertyNameString(m_changingProperty);
+    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;
+    }
+    String errorString;
+    m_cssAgent->setCSSPropertyValue(&errorString, m_element.get(), rule ? rule->style() : m_element->style(), m_changingProperty, value, forceImportant);
+    return errorString.isEmpty();
+}
+
 } // namespace blink