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"
-#include "core/css/CSSRuleList.h"
+#include "core/css/CSSStyleRule.h"
 #include "core/css/MediaList.h"
 #include "core/dom/NodeComputedStyle.h"
 #include "core/dom/StaticNodeList.h"
 #include "core/frame/FrameView.h"
 #include "core/inspector/InspectorCSSAgent.h"
 #include "core/inspector/InspectorDOMAgent.h"
 #include "core/inspector/InspectorHighlight.h"
 #include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutObject.h"
@@ skipping 116 matching lines @@
 }
 
 float toValidValue(CSSPropertyID propertyId, float newValue)
 {
     if (CSSPropertyPaddingBottom <= propertyId && propertyId <= CSSPropertyPaddingTop)
         return newValue >= 0 ? newValue : 0;
 
     return newValue;
 }
 
-bool comparePairs(const std::pair<unsigned, CSSStyleRule*>& lhs, const std::pair<unsigned, CSSStyleRule*>& rhs)
-{
-    return lhs.first < rhs.first;
-}
-
 InspectorHighlightConfig affectedNodesHighlightConfig()
 {
     // TODO: find a better color
     InspectorHighlightConfig config;
     config.content = Color(95, 127, 162, 100);
     config.padding = Color(95, 127, 162, 100);
     config.margin = Color(95, 127, 162, 100);
     return config;
 }
 
@@ skipping 39 matching lines @@
 
 } // namespace
 
 LayoutEditor::LayoutEditor(InspectorCSSAgent* cssAgent, InspectorDOMAgent* domAgent)
     : m_element(nullptr)
     , m_cssAgent(cssAgent)
     , m_domAgent(domAgent)
     , m_changingProperty(CSSPropertyInvalid)
     , m_propertyInitialValue(0)
     , m_isDirty(false)
-    , m_currentRuleIndex(-1)
+    , m_matchedRules(StaticCSSRuleList::create())
+    , m_currentRuleIndex(0)
 {
 }
 
 DEFINE_TRACE(LayoutEditor)
 {
     visitor->trace(m_element);
     visitor->trace(m_cssAgent);
     visitor->trace(m_domAgent);
     visitor->trace(m_matchedRules);
 }
 
 void LayoutEditor::selectNode(Node* node)
 {
     Element* element = node && node->isElementNode() ? toElement(node) : nullptr;
     if (element == m_element)
         return;
 
     ASSERT(!m_isDirty);
     m_element = element;
     m_changingProperty = CSSPropertyInvalid;
     m_propertyInitialValue = 0;
-    initializeCSSRules();
+    m_matchedRules = m_cssAgent->matchedRulesList(m_element.get());
+    m_currentRuleIndex = m_matchedRules->length();
 }
 
 PassRefPtr<JSONObject> LayoutEditor::buildJSONInfo() const
 {
     if (!m_element)
         return nullptr;
 
     FloatQuad content, padding, border, margin;
     InspectorHighlight::buildNodeQuads(m_element.get(), &content, &padding, &border, &margin);
     FloatQuad orthogonals = orthogonalVectors(padding);
@@ skipping 13 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<CSSStyleDeclaration> style = m_cssAgent->findEffectiveDeclaration(property, m_matchedRules.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;
 }
 
 void LayoutEditor::clearSelection(bool commitChanges)
 {
     ErrorString errorString;
     if (commitChanges)
         m_domAgent->markUndoableState(&errorString);
     else if (m_isDirty)
         m_domAgent->undo(&errorString);
 
     m_element.clear();
     m_isDirty = false;
-    m_matchedRules.clear();
-    m_currentRuleIndex = -1;
+    m_matchedRules = StaticCSSRuleList::create();
+    m_currentRuleIndex = 0;
 }
 
-void LayoutEditor::initializeCSSRules()
+bool LayoutEditor::currentStyleIsInline()
 {
-    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);
-    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);
-        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);
-};
+    return m_currentRuleIndex == m_matchedRules->length();
+}
 
 void LayoutEditor::nextSelector()
 {
-    if (static_cast<size_t>(m_currentRuleIndex + 1) == m_matchedRules.size())
+    if (m_currentRuleIndex == 0)
+        return;
+
+    m_currentRuleIndex--;
+}
+
+void LayoutEditor::previousSelector()
+{
+    if (currentStyleIsInline())
         return;
 
     m_currentRuleIndex++;
 }
 
-void LayoutEditor::previousSelector()
-{
-    if (m_currentRuleIndex == -1)
-        return;
-
-    m_currentRuleIndex--;
-}
-
 String LayoutEditor::currentSelectorInfo()
 {
     if (!m_element)
         return String();
 
     RefPtr<JSONObject> object = JSONObject::create();
-    String currentSelectorText = m_currentRuleIndex == -1 ? "inline style" : m_matchedRules[m_currentRuleIndex]->selectorText();
+    String currentSelectorText = currentStyleIsInline() ? "inline style" : toCSSStyleRule(m_matchedRules->item(m_currentRuleIndex))->selectorText();
     object->setString("selector", currentSelectorText);
 
     Document* ownerDocument = m_element->ownerDocument();
-    if (!ownerDocument->isActive() || m_currentRuleIndex == -1)
+    if (!ownerDocument->isActive() || currentStyleIsInline())
         return object->toJSONString();
 
-    if (m_currentRuleIndex != -1) {
-        bool hasSameSelectors = false;
-        for (size_t i = 0; i < m_matchedRules.size(); i++) {
-            if (i != static_cast<unsigned>(m_currentRuleIndex) && m_matchedRules[i]->selectorText() == currentSelectorText) {
-                hasSameSelectors = true;
-                break;
-            }
-        }
-
-        if (hasSameSelectors) {
-            Vector<String> medias;
-            buildMediaListChain(m_matchedRules[m_currentRuleIndex].get(), medias);
-            RefPtr<JSONArray> mediasJSONArray = JSONArray::create();
-            for (size_t i = 0; i < medias.size(); ++i)
-                mediasJSONArray->pushString(medias[i]);
-
-            object->setArray("medias", mediasJSONArray.release());
+    bool hasSameSelectors = false;
+    for (unsigned i = 0; i < m_matchedRules->length(); i++) {
+        if (i != m_currentRuleIndex && toCSSStyleRule(m_matchedRules->item(i))->selectorText() == currentSelectorText) {
+            hasSameSelectors = true;
+            break;
         }
     }
 
+    if (hasSameSelectors) {
+        Vector<String> medias;
+        buildMediaListChain(m_matchedRules->item(m_currentRuleIndex), medias);
+        RefPtr<JSONArray> mediasJSONArray = JSONArray::create();
+        for (size_t i = 0; i < medias.size(); ++i)
+            mediasJSONArray->pushString(medias[i]);
+
+        object->setArray("medias", mediasJSONArray.release());
+    }
+
     TrackExceptionState exceptionState;
-    RefPtrWillBeRawPtr<StaticElementList> elements = ownerDocument->querySelectorAll(AtomicString(m_matchedRules[m_currentRuleIndex]->selectorText()), exceptionState);
+    RefPtrWillBeRawPtr<StaticElementList> elements = ownerDocument->querySelectorAll(AtomicString(currentSelectorText), exceptionState);
 
     if (!elements || exceptionState.hadException())
         return object->toJSONString();
 
     RefPtr<JSONArray> highlights = JSONArray::create();
     InspectorHighlightConfig config = affectedNodesHighlightConfig();
     for (unsigned i = 0; i < elements->length(); ++i) {
         Element* element = elements->item(i);
         if (element == m_element)
             continue;
 
         InspectorHighlight highlight(element, config, false);
         highlights->pushObject(highlight.asJSONObject());
     }
 
     object->setArray("nodes", highlights.release());
     return object->toJSONString();
 }
 
+bool LayoutEditor::setCSSPropertyValueInCurrentRule(const String& value)
+{
+    if (!m_element)
+        return false;
+
+    RefPtrWillBeRawPtr<CSSStyleDeclaration> effectiveDeclaration = m_cssAgent->findEffectiveDeclaration(m_changingProperty, m_matchedRules.get(), m_element->style());
+    bool forceImportant = false;
+
+    if (effectiveDeclaration) {
+        CSSStyleRule* effectiveRule = nullptr;
+        if (effectiveDeclaration->parentRule() && effectiveDeclaration->parentRule()->type() == CSSRule::STYLE_RULE)
+            effectiveRule = toCSSStyleRule(effectiveDeclaration->parentRule());
+
+        unsigned effectiveRuleIndex = m_matchedRules->length();
+        for (unsigned i = 0; i < m_matchedRules->length(); ++i) {
+            if (m_matchedRules->item(i) == effectiveRule) {
+                effectiveRuleIndex = i;
+                break;
+            }
+        }
+        forceImportant = effectiveDeclaration->getPropertyPriority(getPropertyNameString(m_changingProperty)) == "important";
+        forceImportant |= effectiveRuleIndex > m_currentRuleIndex;
+    }
+
+    CSSStyleDeclaration* style = currentStyleIsInline() ? m_element->style() : toCSSStyleRule(m_matchedRules->item(m_currentRuleIndex))->style();
+
+    String errorString;
+    m_cssAgent->setCSSPropertyValue(&errorString, m_element.get(), style, m_changingProperty, value, forceImportant);
+    return errorString.isEmpty();
+}
+
 } // namespace blink