DevTools: [CSS] use setStyleText as undo action for setPropertyText

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 553 matching lines @@
     if (propertyCount < 2)
         return false;
 
     // Check for the proper propertyText termination (the parser could at least restore to the PROPERTY_NAME state).
     if (propertyData.at(propertyCount - 1).name != bogusPropertyName)
         return false;
 
     return true;
 }
 
-bool InspectorStyle::setPropertyText(unsigned index, const String& propertyText, bool overwrite, String* oldText, ExceptionState& exceptionState)
+bool InspectorStyle::setPropertyText(unsigned index, const String& propertyText, bool overwrite, ExceptionState& exceptionState)
 {
     ASSERT(m_parentStyleSheet);
 
     if (!m_parentStyleSheet->ensureParsedDataReady()) {
         exceptionState.throwDOMException(NotFoundError, "The parent style sheet's data hasn't been processed.");
         return false;
     }
 
     if (!propertyText.stripWhiteSpace().isEmpty()) {
         if (!verifyPropertyText(propertyText, false) && !verifyPropertyText(propertyText, true)) {
@@ skipping 17 matching lines @@
 
     Vector<InspectorStyleProperty> allProperties;
     populateAllProperties(allProperties);
 
     InspectorStyleTextEditor editor(&allProperties, text, newLineAndWhitespaceDelimiters());
     if (overwrite) {
         if (index >= allProperties.size()) {
             exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is greater than or equal to the maximum bound (" + String::number(allProperties.size()) + ").");
             return false;
         }
-        *oldText = allProperties.at(index).rawText;
         editor.replaceProperty(index, propertyText);
-    } else
+    } else {
         editor.insertProperty(index, propertyText, sourceData->ruleBodyRange.length());
+    }
 
-    return applyStyleText(editor.styleText());
+    return m_parentStyleSheet->setStyleText(m_styleId, editor.styleText());
 }
 
 bool InspectorStyle::styleText(String* result) const
 {
     RefPtr<CSSRuleSourceData> sourceData = extractSourceData();
     if (!sourceData)
         return false;
 
     String styleSheetText;
     bool success = m_parentStyleSheet->getText(&styleSheetText);
@@ skipping 98 matching lines @@
     return result.release();
 }
 
 PassRefPtr<CSSRuleSourceData> InspectorStyle::extractSourceData() const
 {
     if (!m_parentStyleSheet || !m_parentStyleSheet->ensureParsedDataReady())
         return nullptr;
     return m_parentStyleSheet->ruleSourceDataFor(m_style.get());
 }
 
-bool InspectorStyle::applyStyleText(const String& text)
-{
-    return m_parentStyleSheet->setStyleText(m_style.get(), text);
-}
-
 String InspectorStyle::shorthandValue(const String& shorthandProperty) const
 {
     String value = m_style->getPropertyValue(shorthandProperty);
     if (value.isEmpty()) {
         StringBuilder builder;
 
         for (unsigned i = 0; i < m_style->length(); ++i) {
             String individualProperty = m_style->item(i);
             if (m_style->getPropertyShorthand(individualProperty) != shorthandProperty)
                 continue;
@@ skipping 81 matching lines @@
 {
     return m_parentStyleSheet->ownerDocument();
 }
 
 InspectorStyleSheetBase::InspectorStyleSheetBase(const String& id, Listener* listener)
     : m_id(id)
     , m_listener(listener)
 {
 }
 
-bool InspectorStyleSheetBase::setPropertyText(const InspectorCSSId& id, unsigned propertyIndex, const String& text, bool overwrite, String* oldText, ExceptionState& exceptionState)
+bool InspectorStyleSheetBase::setPropertyText(const InspectorCSSId& id, unsigned propertyIndex, const String& text, bool overwrite, ExceptionState& exceptionState)
 {
     RefPtr<InspectorStyle> inspectorStyle = inspectorStyleForId(id);
     if (!inspectorStyle) {
         exceptionState.throwDOMException(NotFoundError, "No property could be found for the given ID.");
         return false;
     }
+    return inspectorStyle->setPropertyText(propertyIndex, text, overwrite, exceptionState);
+}
 
-    bool success = inspectorStyle->setPropertyText(propertyIndex, text, overwrite, oldText, exceptionState);
-    if (success)
-        fireStyleSheetChanged();
-    return success;
+bool InspectorStyleSheetBase::getStyleText(const InspectorCSSId& id, String* text)
+{
+    RefPtr<InspectorStyle> inspectorStyle = inspectorStyleForId(id);
+    if (!inspectorStyle)
+        return false;
+    return inspectorStyle->styleText(text);
 }
 
 void InspectorStyleSheetBase::fireStyleSheetChanged()
 {
     if (listener())
         listener()->styleSheetChanged(this);
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorStyleSheetBase::buildObjectForStyle(CSSStyleDeclaration* style)
 {
@@ skipping 518 matching lines @@
     }
 }
 
 void InspectorStyleSheet::ensureFlatRules() const
 {
     // We are fine with redoing this for empty stylesheets as this will run fast.
     if (m_flatRules.isEmpty())
         collectFlatRules(asCSSRuleList(pageStyleSheet()), &m_flatRules);
 }
 
-bool InspectorStyleSheet::setStyleText(CSSStyleDeclaration* style, const String& text)
+bool InspectorStyleSheet::setStyleText(const InspectorCSSId& id, const String& text)
 {
+    CSSStyleDeclaration* style = styleForId(id);
+    if (!style)
+        return false;
+
     if (!ensureParsedDataReady())
         return false;
 
     String patchedStyleSheetText;
     bool success = styleSheetTextWithChangedStyle(style, text, &patchedStyleSheetText);
     if (!success)
         return false;
 
-    InspectorCSSId id = styleId(style);
-    if (id.isEmpty())
-        return false;
-
     TrackExceptionState exceptionState;
     style->setCSSText(text, exceptionState);
-    if (!exceptionState.hadException())
+    if (!exceptionState.hadException()) {
         m_parsedStyleSheet->setText(patchedStyleSheetText);
+        fireStyleSheetChanged();
+    }
 
     return !exceptionState.hadException();
 }
 
 bool InspectorStyleSheet::styleSheetTextWithChangedStyle(CSSStyleDeclaration* style, const String& newStyleText, String* result)
 {
     if (!style)
         return false;
-
     if (!ensureParsedDataReady())
         return false;
 
     RefPtr<CSSRuleSourceData> sourceData = ruleSourceDataFor(style);
     unsigned bodyStart = sourceData->ruleBodyRange.start;
     unsigned bodyEnd = sourceData->ruleBodyRange.end;
     ASSERT(bodyStart <= bodyEnd);
 
     String text = m_parsedStyleSheet->text();
     ASSERT_WITH_SECURITY_IMPLICATION(bodyEnd <= text.length()); // bodyEnd is exclusive
@@ skipping 61 matching lines @@
 void InspectorStyleSheetForInlineStyle::didModifyElementAttribute()
 {
     m_isStyleTextValid = false;
     if (m_element->isStyledElement() && m_element->style() != m_inspectorStyle->cssStyle())
         m_inspectorStyle = InspectorStyle::create(InspectorCSSId(id(), 0), inlineStyle(), this);
     m_ruleSourceData.clear();
 }
 
 bool InspectorStyleSheetForInlineStyle::setText(const String& text, ExceptionState& exceptionState)
 {
-    bool success = setStyleText(inlineStyle(), text);
+    bool success = setStyleText(InspectorCSSId(id(), 0), text);
     if (!success)
         exceptionState.throwDOMException(SyntaxError, "Style sheet text is invalid.");
     else
         fireStyleSheetChanged();
     return success;
 }
 
 bool InspectorStyleSheetForInlineStyle::getText(String* result) const
 {
     if (!m_isStyleTextValid) {
         m_styleText = elementStyleText();
         m_isStyleTextValid = true;
     }
     *result = m_styleText;
     return true;
 }
 
-bool InspectorStyleSheetForInlineStyle::setStyleText(CSSStyleDeclaration* style, const String& text)
+bool InspectorStyleSheetForInlineStyle::setStyleText(const InspectorCSSId& id, const String& text)
 {
+    CSSStyleDeclaration* style = styleForId(id);
+    if (!style)
+        return false;
     ASSERT_UNUSED(style, style == inlineStyle());
     TrackExceptionState exceptionState;
 
     {
         InspectorCSSAgent::InlineStyleOverrideScope overrideScope(m_element->ownerDocument());
         m_element->setAttribute("style", AtomicString(text), exceptionState);
     }
-
-    m_styleText = text;
-    m_isStyleTextValid = true;
-    m_ruleSourceData.clear();
+    if (!exceptionState.hadException()) {
+        m_styleText = text;
+        m_isStyleTextValid = true;
+        m_ruleSourceData.clear();
+        fireStyleSheetChanged();
+    }
     return !exceptionState.hadException();
 }
 
 Document* InspectorStyleSheetForInlineStyle::ownerDocument() const
 {
     return &m_element->document();
 }
 
 bool InspectorStyleSheetForInlineStyle::ensureParsedDataReady()
 {
@@ skipping 49 matching lines @@
 
     RefPtrWillBeRawPtr<MutableStylePropertySet> tempDeclaration = MutableStylePropertySet::create();
     RuleSourceDataList ruleSourceDataResult;
     StyleSheetHandler handler(m_styleText, &m_element->document(), m_element->document().elementSheet().contents(), &ruleSourceDataResult);
     createCSSParser(&m_element->document())->parseDeclaration(tempDeclaration.get(), m_styleText, &handler, m_element->document().elementSheet().contents());
     return ruleSourceDataResult.first().release();
 }
 
 } // namespace WebCore