DevTools: introduce CSS.setStyleText, we'll migrate setPropertyText to it later.

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 314 matching lines @@
     RefPtrWillBeRawPtr<CSSMediaQuerySourceData> data = CSSMediaQuerySourceData::create();
     m_currentMediaQueryData = data;
     m_currentRuleDataStack.last()->mediaSourceData->queryData.append(data);
 }
 
 void StyleSheetHandler::endMediaQuery()
 {
     m_currentMediaQueryData.clear();
 }
 
+bool verifyRuleText(Document* document, const String& ruleText)
+{
+    DEFINE_STATIC_LOCAL(String, bogusPropertyName, ("-webkit-boguz-propertee"));
+    RuleSourceDataList sourceData;
+    String text = ruleText + " div { " + bogusPropertyName + ": none; }";
+    StyleSheetHandler handler(text, document, &sourceData);
+    CSSParser::parseSheetForInspector(parserContextForDocument(document), text, handler);
+    unsigned ruleCount = sourceData.size();
+
+    // Exactly two rules should be parsed.
+    if (ruleCount != 2)
+        return false;
+
+    // Added rule must be style rule.
+    if (!sourceData.at(0)->styleSourceData)
+        return false;
+
+    WillBeHeapVector<CSSPropertySourceData>& propertyData = sourceData.at(1)->styleSourceData->propertyData;
+    unsigned propertyCount = propertyData.size();
+
+    // Exactly one property should be in rule.
+    if (propertyCount != 1)
+        return false;
+
+    // Check for the property name.
+    if (propertyData.at(0).name != bogusPropertyName)
+        return false;
+
+    return true;
+}
+
+bool verifyStyleText(Document* document, const String& text)
+{
+    return verifyRuleText(document, "div {" + text + "}");
+}
+
+bool verifySelectorText(Document* document, const String& selectorText)
+{
+    DEFINE_STATIC_LOCAL(String, bogusPropertyName, ("-webkit-boguz-propertee"));
+    RuleSourceDataList sourceData;
+    String text = selectorText + " { " + bogusPropertyName + ": none; }";
+    StyleSheetHandler handler(text, document, &sourceData);
+    CSSParser::parseSheetForInspector(parserContextForDocument(document), text, handler);
+
+    // Exactly one rule should be parsed.
+    unsigned ruleCount = sourceData.size();
+    if (ruleCount != 1 || sourceData.at(0)->type != StyleRule::Style)
+        return false;
+
+    // Exactly one property should be in style rule.
+    WillBeHeapVector<CSSPropertySourceData>& propertyData = sourceData.at(0)->styleSourceData->propertyData;
+    unsigned propertyCount = propertyData.size();
+    if (propertyCount != 1)
+        return false;
+
+    // Check for the property name.
+    if (propertyData.at(0).name != bogusPropertyName)
+        return false;
+
+    return true;
+}
+
+bool verifyMediaText(Document* document, const String& mediaText)
+{
+    DEFINE_STATIC_LOCAL(String, bogusPropertyName, ("-webkit-boguz-propertee"));
+    RuleSourceDataList sourceData;
+    String text = "@media " + mediaText + " { div { " + bogusPropertyName + ": none; } }";
+    StyleSheetHandler handler(text, document, &sourceData);
+    CSSParser::parseSheetForInspector(parserContextForDocument(document), text, handler);
+
+    // Exactly one media rule should be parsed.
+    unsigned ruleCount = sourceData.size();
+    if (ruleCount != 1 || sourceData.at(0)->type != StyleRule::Media)
+        return false;
+
+    // Media rule should have exactly one style rule child.
+    RuleSourceDataList& childSourceData = sourceData.at(0)->childRules;
+    ruleCount = childSourceData.size();
+    if (ruleCount != 1 || !childSourceData.at(0)->styleSourceData)
+        return false;
+
+    // Exactly one property should be in style rule.
+    WillBeHeapVector<CSSPropertySourceData>& propertyData = childSourceData.at(0)->styleSourceData->propertyData;
+    unsigned propertyCount = propertyData.size();
+    if (propertyCount != 1)
+        return false;
+
+    // Check for the property name.
+    if (propertyData.at(0).name != bogusPropertyName)
+        return false;
+
+    return true;
+}
+
 } // namespace
 
 class ParsedStyleSheet : public NoBaseWillBeGarbageCollectedFinalized<ParsedStyleSheet> {
 public:
     static PassOwnPtrWillBeRawPtr<ParsedStyleSheet> create(CSSStyleSheet* pageStyleSheet)
     {
         return adoptPtrWillBeNoop(new ParsedStyleSheet(pageStyleSheet));
     }
 
     const String& text() const { ASSERT(m_hasText); return m_text; }
@@ skipping 655 matching lines @@
         m_pageStyleSheet->contents()->parseString(text);
     }
 
     if (listener())
         listener()->didReparseStyleSheet();
     onStyleSheetTextChanged();
     m_pageStyleSheet->ownerDocument()->styleResolverChanged(FullStyleUpdate);
     return true;
 }
 
-CSSStyleRule* InspectorStyleSheet::setRuleSelector(const SourceRange& range, const String& text, SourceRange* newRange, String* oldText, ExceptionState& exceptionState)
+RefPtrWillBeRawPtr<CSSStyleRule> InspectorStyleSheet::setRuleSelector(const SourceRange& range, const String& text, SourceRange* newRange, String* oldText, ExceptionState& exceptionState)
 {
-    if (!verifySelectorText(text)) {
+    if (!verifySelectorText(ownerDocument(), text)) {
         exceptionState.throwDOMException(SyntaxError, "Selector or media text is not valid.");
         return nullptr;
     }
 
     CSSRule* rule = nullptr;
     CSSRuleSourceData* sourceData = nullptr;
     if (!findRuleByHeaderRange(range, &rule, &sourceData) || !sourceData->styleSourceData || rule->type() != CSSRule::STYLE_RULE) {
         exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing source range");
         return nullptr;
     }
 
-    CSSStyleRule* styleRule = InspectorCSSAgent::asCSSStyleRule(rule);
+    RefPtrWillBeRawPtr<CSSStyleRule>  styleRule = InspectorCSSAgent::asCSSStyleRule(rule);
     styleRule->setSelectorText(text);
 
     replaceText(sourceData->ruleHeaderRange, text, newRange, oldText);
     onStyleSheetTextChanged();
 
     return styleRule;
 }
 
-CSSMediaRule* InspectorStyleSheet::setMediaRuleText(const SourceRange& range, const String& text, SourceRange* newRange, String* oldText, ExceptionState& exceptionState)
+RefPtrWillBeRawPtr<CSSStyleRule> InspectorStyleSheet::setStyleText(const SourceRange& range, const String& text, SourceRange* newRange, String* oldText, ExceptionState& exceptionState)
 {
-    if (!verifyMediaText(text)) {
+    if (!verifyStyleText(ownerDocument(), text)) {
+        exceptionState.throwDOMException(SyntaxError, "Style text is not valid.");
+        return nullptr;
+    }
+
+    CSSRule* rule = nullptr;
+    CSSRuleSourceData* sourceData = nullptr;
+    if (!findRuleByBodyRange(range, &rule, &sourceData) || !sourceData->styleSourceData || rule->type() != CSSRule::STYLE_RULE) {
+        exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing style source range");
+        return nullptr;
+    }
+
+    RefPtrWillBeRawPtr<CSSStyleRule> styleRule = InspectorCSSAgent::asCSSStyleRule(rule);
+    styleRule->style()->setCSSText(text, exceptionState);
+
+    replaceText(sourceData->ruleBodyRange, text, newRange, oldText);
+    onStyleSheetTextChanged();
+
+    return styleRule;
+}
+
+RefPtrWillBeRawPtr<CSSMediaRule> InspectorStyleSheet::setMediaRuleText(const SourceRange& range, const String& text, SourceRange* newRange, String* oldText, ExceptionState& exceptionState)
+{
+    if (!verifyMediaText(ownerDocument(), text)) {
         exceptionState.throwDOMException(SyntaxError, "Selector or media text is not valid.");
         return nullptr;
     }
 
     CSSRule* rule = nullptr;
     CSSRuleSourceData* sourceData = nullptr;
     if (!findRuleByHeaderRange(range, &rule, &sourceData) || !sourceData->mediaSourceData || rule->type() != CSSRule::MEDIA_RULE) {
         exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing source range");
         return nullptr;
     }
 
-    CSSMediaRule* mediaRule = InspectorCSSAgent::asCSSMediaRule(rule);
+    RefPtrWillBeRawPtr<CSSMediaRule>  mediaRule = InspectorCSSAgent::asCSSMediaRule(rule);
     mediaRule->media()->setMediaText(text);
 
     replaceText(sourceData->ruleHeaderRange, text, newRange, oldText);
     onStyleSheetTextChanged();
 
     return mediaRule;
 }
 
 unsigned InspectorStyleSheet::ruleIndexBySourceRange(const CSSMediaRule* parentMediaRule, const SourceRange& sourceRange)
 {
@@ skipping 58 matching lines @@
         return insertCSSOMRuleInStyleSheet(sourceRange, ruleText, exceptionState);
 
     RefPtrWillBeRawPtr<CSSRule> rule = m_flatRules.at(containingRuleIndex);
     if (rule->type() != CSSRule::MEDIA_RULE) {
         exceptionState.throwDOMException(NotFoundError, "Cannot insert rule in non-media rule.");
         return nullptr;
     }
     return insertCSSOMRuleInMediaRule(toCSSMediaRule(rule.get()), sourceRange, ruleText, exceptionState);
 }
 
-bool InspectorStyleSheet::verifyRuleText(const String& ruleText)
-{
-    DEFINE_STATIC_LOCAL(String, bogusPropertyName, ("-webkit-boguz-propertee"));
-    RuleSourceDataList sourceData;
-    String text = ruleText + " div { " + bogusPropertyName + ": none; }";
-    StyleSheetHandler handler(text, ownerDocument(), &sourceData);
-    CSSParser::parseSheetForInspector(parserContextForDocument(ownerDocument()), text, handler);
-    unsigned ruleCount = sourceData.size();
-
-    // Exactly two rules should be parsed.
-    if (ruleCount != 2)
-        return false;
-
-    // Added rule must be style rule.
-    if (!sourceData.at(0)->styleSourceData)
-        return false;
-
-    WillBeHeapVector<CSSPropertySourceData>& propertyData = sourceData.at(1)->styleSourceData->propertyData;
-    unsigned propertyCount = propertyData.size();
-
-    // Exactly one property should be in rule.
-    if (propertyCount != 1)
-        return false;
-
-    // Check for the property name.
-    if (propertyData.at(0).name != bogusPropertyName)
-        return false;
-
-    return true;
-}
-
-bool InspectorStyleSheet::verifySelectorText(const String& selectorText)
-{
-    DEFINE_STATIC_LOCAL(String, bogusPropertyName, ("-webkit-boguz-propertee"));
-    RuleSourceDataList sourceData;
-    String text = selectorText + " { " + bogusPropertyName + ": none; }";
-    StyleSheetHandler handler(text, ownerDocument(), &sourceData);
-    CSSParser::parseSheetForInspector(parserContextForDocument(ownerDocument()), text, handler);
-
-    // Exactly one rule should be parsed.
-    unsigned ruleCount = sourceData.size();
-    if (ruleCount != 1 || sourceData.at(0)->type != StyleRule::Style)
-        return false;
-
-    // Exactly one property should be in style rule.
-    WillBeHeapVector<CSSPropertySourceData>& propertyData = sourceData.at(0)->styleSourceData->propertyData;
-    unsigned propertyCount = propertyData.size();
-    if (propertyCount != 1)
-        return false;
-
-    // Check for the property name.
-    if (propertyData.at(0).name != bogusPropertyName)
-        return false;
-
-    return true;
-}
-
-bool InspectorStyleSheet::verifyMediaText(const String& mediaText)
-{
-    DEFINE_STATIC_LOCAL(String, bogusPropertyName, ("-webkit-boguz-propertee"));
-    RuleSourceDataList sourceData;
-    String text = "@media " + mediaText + " { div { " + bogusPropertyName + ": none; } }";
-    StyleSheetHandler handler(text, ownerDocument(), &sourceData);
-    CSSParser::parseSheetForInspector(parserContextForDocument(ownerDocument()), text, handler);
-
-    // Exactly one media rule should be parsed.
-    unsigned ruleCount = sourceData.size();
-    if (ruleCount != 1 || sourceData.at(0)->type != StyleRule::Media)
-        return false;
-
-    // Media rule should have exactly one style rule child.
-    RuleSourceDataList& childSourceData = sourceData.at(0)->childRules;
-    ruleCount = childSourceData.size();
-    if (ruleCount != 1 || !childSourceData.at(0)->styleSourceData)
-        return false;
-
-    // Exactly one property should be in style rule.
-    WillBeHeapVector<CSSPropertySourceData>& propertyData = childSourceData.at(0)->styleSourceData->propertyData;
-    unsigned propertyCount = propertyData.size();
-    if (propertyCount != 1)
-        return false;
-
-    // Check for the property name.
-    if (propertyData.at(0).name != bogusPropertyName)
-        return false;
-
-    return true;
-}
-
-CSSStyleRule* InspectorStyleSheet::addRule(const String& ruleText, const SourceRange& location, SourceRange* addedRange, ExceptionState& exceptionState)
+RefPtrWillBeRawPtr<CSSStyleRule> InspectorStyleSheet::addRule(const String& ruleText, const SourceRange& location, SourceRange* addedRange, ExceptionState& exceptionState)
 {
     if (location.start != location.end) {
         exceptionState.throwDOMException(NotFoundError, "Source range must be collapsed.");
         return nullptr;
     }
 
-    if (!verifyRuleText(ruleText)) {
+    if (!verifyRuleText(ownerDocument(), ruleText)) {
         exceptionState.throwDOMException(SyntaxError, "Rule text is not valid.");
         return nullptr;
     }
 
     if (!ensureParsedDataReady()) {
         exceptionState.throwDOMException(NotFoundError, "Cannot parse style sheet.");
         return nullptr;
     }
     ensureFlatRules();
 
-    CSSStyleRule* styleRule = insertCSSOMRuleBySourceRange(location, ruleText, exceptionState);
+    RefPtrWillBeRawPtr<CSSStyleRule> styleRule = insertCSSOMRuleBySourceRange(location, ruleText, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     replaceText(location, ruleText, addedRange, nullptr);
     m_flatRules.clear();
 
     onStyleSheetTextChanged();
     return styleRule;
 }
 
@@ skipping 363 matching lines @@
             *pRule = m_flatRules.at(i).get();
             if (!(*pRule)->parentStyleSheet())
                 return false;
             *pSourceData = ruleSourceData.get();
             return true;
         }
     }
     return false;
 }
 
+bool InspectorStyleSheet::findRuleByBodyRange(const SourceRange& sourceRange, CSSRule** pRule, CSSRuleSourceData** pSourceData)
+{
+    if (!ensureParsedDataReady())
+        return false;
+    ensureFlatRules();
+
+    for (size_t i = 0; i < ruleCount() && i < m_flatRules.size(); ++i) {
+        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = ruleSourceDataAt(i);
+        if (ruleSourceData->ruleBodyRange.start == sourceRange.start && ruleSourceData->ruleBodyRange.end == sourceRange.end) {
+            *pRule = m_flatRules.at(i).get();
+            if (!(*pRule)->parentStyleSheet())
+                return false;
+            *pSourceData = ruleSourceData.get();
+            return true;
+        }
+    }
+    return false;
+}
+
 const CSSRuleVector& InspectorStyleSheet::flatRules()
 {
     ensureFlatRules();
     return m_flatRules;
 }
 
 Document* InspectorStyleSheet::ownerDocument() const
 {
     return m_pageStyleSheet->ownerDocument();
 }
@@ skipping 178 matching lines @@
 void InspectorStyleSheetForInlineStyle::didModifyElementAttribute()
 {
     m_isStyleTextValid = false;
     if (m_element->isStyledElement() && m_element->style() != m_inspectorStyle->cssStyle())
         m_inspectorStyle = InspectorStyle::create(0, inlineStyle(), this);
     m_ruleSourceData.clear();
 }
 
 bool InspectorStyleSheetForInlineStyle::setText(const String& text, ExceptionState& exceptionState)
 {
+    if (!verifyStyleText(ownerDocument(), text)) {
+        exceptionState.throwDOMException(SyntaxError, "Style text is not valid.");
+        return false;
+    }
+
     bool success = setStyleText(0, text);
     if (!success)
         exceptionState.throwDOMException(SyntaxError, "Style sheet text is invalid.");
     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(unsigned ruleIndex, const String& text)
 {
-    CSSStyleDeclaration* style = styleAt(ruleIndex);
-    if (!style)
-        return false;
-    ASSERT_UNUSED(style, style == inlineStyle());
     TrackExceptionState exceptionState;
-
     {
         InspectorCSSAgent::InlineStyleOverrideScope overrideScope(m_element->ownerDocument());
         m_element->setAttribute("style", AtomicString(text), exceptionState);
     }
     if (!exceptionState.hadException()) {
         m_styleText = text;
         m_isStyleTextValid = true;
         m_ruleSourceData.clear();
         onStyleSheetTextChanged();
     }
@@ skipping 65 matching lines @@
 
 DEFINE_TRACE(InspectorStyleSheetForInlineStyle)
 {
     visitor->trace(m_element);
     visitor->trace(m_ruleSourceData);
     visitor->trace(m_inspectorStyle);
     InspectorStyleSheetBase::trace(visitor);
 }
 
 } // namespace blink