DevTools: migrate from CSS.setPropertyText to CSS.setStyleText

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 568 matching lines @@
 
 PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyle::create(unsigned ruleIndex, PassRefPtrWillBeRawPtr<CSSStyleDeclaration> style, InspectorStyleSheetBase* parentStyleSheet)
 {
     return adoptRefWillBeNoop(new InspectorStyle(ruleIndex, style, parentStyleSheet));
 }
 
 InspectorStyle::InspectorStyle(unsigned ruleIndex, PassRefPtrWillBeRawPtr<CSSStyleDeclaration> style, InspectorStyleSheetBase* parentStyleSheet)
     : m_ruleIndex(ruleIndex)
     , m_style(style)
     , m_parentStyleSheet(parentStyleSheet)
-    , m_formatAcquired(false)
 {
     ASSERT(m_style);
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorStyle::buildObjectForStyle() const
 {
     RefPtr<TypeBuilder::CSS::CSSStyle> result = styleWithProperties();
     if (m_parentStyleSheet && !m_parentStyleSheet->id().isEmpty())
         result->setStyleSheetId(m_parentStyleSheet->id());
 
@@ skipping 14 matching lines @@
         const CSSPropertySourceData& propertyEntry = property.sourceData;
         RefPtr<TypeBuilder::CSS::CSSComputedStyleProperty> entry = TypeBuilder::CSS::CSSComputedStyleProperty::create()
             .setName(propertyEntry.name)
             .setValue(propertyEntry.value);
         result->addItem(entry);
     }
 
     return result.release();
 }
 
-bool InspectorStyle::verifyPropertyText(const String& propertyText, bool canOmitSemicolon)
-{
-    DEFINE_STATIC_LOCAL(String, bogusPropertyName, ("-webkit-boguz-propertee"));
-    RuleSourceDataList sourceData;
-    String declarationText = propertyText + (canOmitSemicolon ? ";" : " ") + bogusPropertyName + ": none";
-    StyleSheetHandler handler(declarationText, ownerDocument(), &sourceData);
-    CSSParser::parseDeclarationListForInspector(parserContextForDocument(ownerDocument()), declarationText, handler);
-    WillBeHeapVector<CSSPropertySourceData>& propertyData = sourceData.first()->styleSourceData->propertyData;
-    unsigned propertyCount = propertyData.size();
-
-    // At least one property + the bogus property added just above should be present.
-    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, ExceptionState& exceptionState)
-{
-    ASSERT(m_parentStyleSheet);
-
-    if (m_ruleIndex == UINT_MAX) {
-        exceptionState.throwDOMException(NotFoundError, "The style is read-only.");
-        return false;
-    }
-
-    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)) {
-            exceptionState.throwDOMException(SyntaxError, "The property '" + propertyText + "' could not be set.");
-            return false;
-        }
-    }
-
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = extractSourceData();
-    if (!sourceData) {
-        exceptionState.throwDOMException(NotFoundError, "The property '" + propertyText + "' could not be set.");
-        return false;
-    }
-
-    String text;
-    bool success = styleText(&text);
-    if (!success) {
-        exceptionState.throwDOMException(NotFoundError, "The property '" + propertyText + "' could not be set.");
-        return false;
-    }
-
-    WillBeHeapVector<InspectorStyleProperty> allProperties;
-    populateAllProperties(allProperties);
-
-    InspectorStyleTextEditor editor(&allProperties, text, sourceData->ruleBodyRange, 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;
-        }
-        editor.replaceProperty(index, propertyText);
-    } else {
-        editor.insertProperty(index, propertyText);
-    }
-
-    return m_parentStyleSheet->setStyleText(m_ruleIndex, editor.styleText());
-}
-
 bool InspectorStyle::styleText(String* result) const
 {
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = extractSourceData();
     if (!sourceData)
         return false;
 
     return textForRange(sourceData->ruleBodyRange, result);
 }
 
 bool InspectorStyle::textForRange(const SourceRange& range, String* result) const
@@ skipping 121 matching lines @@
             if (!builder.isEmpty())
                 builder.append(' ');
             builder.append(individualValue);
         }
 
         return builder.toString();
     }
     return value;
 }
 
-NewLineAndWhitespace& InspectorStyle::newLineAndWhitespaceDelimiters() const
-{
-    DEFINE_STATIC_LOCAL(String, defaultPrefix, ("    "));
-
-    if (m_formatAcquired)
-        return m_format;
-
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = extractSourceData();
-    WillBeHeapVector<CSSPropertySourceData>* sourcePropertyData = sourceData ? &(sourceData->styleSourceData->propertyData) : nullptr;
-    int propertyCount = sourcePropertyData ? sourcePropertyData->size() : 0;
-    if (!propertyCount) {
-        m_format.first = "\n";
-        m_format.second = defaultPrefix;
-        return m_format; // Do not remember the default formatting and attempt to acquire it later.
-    }
-
-    String styleSheetText;
-    bool success = m_parentStyleSheet->getText(&styleSheetText);
-    ASSERT_UNUSED(success, success);
-
-    m_formatAcquired = true;
-
-    String candidatePrefix = defaultPrefix;
-    StringBuilder formatLineFeed;
-    StringBuilder prefix;
-    int scanStart = sourceData->ruleBodyRange.start;
-    int propertyIndex = 0;
-    bool isFullPrefixScanned = false;
-    bool lineFeedTerminated = false;
-    while (propertyIndex < propertyCount) {
-        const blink::CSSPropertySourceData& currentProperty = sourcePropertyData->at(propertyIndex++);
-
-        bool processNextProperty = false;
-        int scanEnd = currentProperty.range.start;
-        for (int i = scanStart; i < scanEnd; ++i) {
-            UChar ch = styleSheetText[i];
-            bool isLineFeed = isHTMLLineBreak(ch);
-            if (isLineFeed) {
-                if (!lineFeedTerminated)
-                    formatLineFeed.append(ch);
-                prefix.clear();
-            } else if (isHTMLSpace<UChar>(ch))
-                prefix.append(ch);
-            else {
-                candidatePrefix = prefix.toString();
-                prefix.clear();
-                scanStart = currentProperty.range.end;
-                ++propertyIndex;
-                processNextProperty = true;
-                break;
-            }
-            if (!isLineFeed && formatLineFeed.length())
-                lineFeedTerminated = true;
-        }
-        if (!processNextProperty) {
-            isFullPrefixScanned = true;
-            break;
-        }
-    }
-
-    m_format.first = formatLineFeed.toString();
-    m_format.second = isFullPrefixScanned ? prefix.toString() : candidatePrefix;
-    return m_format;
-}
-
 Document* InspectorStyle::ownerDocument() const
 {
     return m_parentStyleSheet->ownerDocument();
 }
 
 DEFINE_TRACE(InspectorStyle)
 {
     visitor->trace(m_style);
     visitor->trace(m_parentStyleSheet);
 }
 
 InspectorStyleSheetBase::InspectorStyleSheetBase(const String& id, Listener* listener)
     : m_id(id)
     , m_listener(listener)
     , m_lineEndings(adoptPtr(new LineEndings()))
 {
 }
 
-bool InspectorStyleSheetBase::setPropertyText(unsigned ruleIndex, unsigned propertyIndex, const String& text, bool overwrite, ExceptionState& exceptionState)
-{
-    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = inspectorStyleAt(ruleIndex);
-    if (!inspectorStyle) {
-        exceptionState.throwDOMException(NotFoundError, "No property could be found for the given ID.");
-        return false;
-    }
-    return inspectorStyle->setPropertyText(propertyIndex, text, overwrite, exceptionState);
-}
-
-bool InspectorStyleSheetBase::getStyleText(unsigned ruleIndex, String* text)
-{
-    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = inspectorStyleAt(ruleIndex);
-    if (!inspectorStyle)
-        return false;
-    return inspectorStyle->styleText(text);
-}
-
 void InspectorStyleSheetBase::onStyleSheetTextChanged()
 {
     m_lineEndings = adoptPtr(new LineEndings());
     if (listener())
         listener()->styleSheetChanged(this);
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorStyleSheetBase::buildObjectForStyle(CSSStyleDeclaration* style)
 {
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = nullptr;
@@ skipping 39 matching lines @@
     if (lineNumber >= endings->size())
         return false;
     unsigned charactersInLine = lineNumber > 0 ? endings->at(lineNumber) - endings->at(lineNumber - 1) - 1 : endings->at(0);
     if (columnNumber > charactersInLine)
         return false;
     TextPosition position(OrdinalNumber::fromZeroBasedInt(lineNumber), OrdinalNumber::fromZeroBasedInt(columnNumber));
     *offset = position.toOffset(*endings).zeroBasedInt();
     return true;
 }
 
-bool InspectorStyleSheetBase::findPropertyByRange(const SourceRange& sourceRange, unsigned* ruleIndex, unsigned* propertyIndex, bool* overwrite)
-{
-    if (!ensureParsedDataReady())
-        return false;
-    for (size_t i = 0; i < ruleCount(); ++i) {
-        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = ruleSourceDataAt(i);
-        RefPtrWillBeRawPtr<CSSStyleSourceData> styleSourceData = ruleSourceData->styleSourceData;
-        if (!styleSourceData)
-            continue;
-        if (ruleSourceData->ruleBodyRange.end < sourceRange.start || sourceRange.end < ruleSourceData->ruleBodyRange.start)
-            continue;
-        WillBeHeapVector<CSSPropertySourceData>& propertyData = styleSourceData->propertyData;
-        for (size_t j = 0; j < propertyData.size(); ++j) {
-            CSSPropertySourceData& property = propertyData.at(j);
-            unsigned styleStart = ruleSourceData->ruleBodyRange.start;
-            if (sourceRange.length() && property.range.start == sourceRange.start && property.range.end == sourceRange.end) {
-                *ruleIndex = i;
-                *propertyIndex = j;
-                *overwrite = true;
-                return true;
-            }
-            if (!sourceRange.length() && styleStart <= sourceRange.start && sourceRange.start <= property.range.start) {
-                *ruleIndex = i;
-                *propertyIndex = j;
-                *overwrite = false;
-                return true;
-            }
-        }
-        if (!sourceRange.length() && ruleSourceData->ruleBodyRange.start <= sourceRange.start && sourceRange.start <= ruleSourceData->ruleBodyRange.end) {
-            *ruleIndex = i;
-            *propertyIndex = propertyData.size();
-            *overwrite = false;
-            return true;
-        }
-    }
-    return false;
-}
-
 PassRefPtrWillBeRawPtr<InspectorStyleSheet> InspectorStyleSheet::create(InspectorResourceAgent* resourceAgent, const String& id, PassRefPtrWillBeRawPtr<CSSStyleSheet> pageStyleSheet, TypeBuilder::CSS::StyleSheetOrigin::Enum origin, const String& documentURL, InspectorCSSAgent* cssAgent)
 {
     return adoptRefWillBeNoop(new InspectorStyleSheet(resourceAgent, id, pageStyleSheet, origin, documentURL, cssAgent));
 }
 
 InspectorStyleSheet::InspectorStyleSheet(InspectorResourceAgent* resourceAgent, const String& id, PassRefPtrWillBeRawPtr<CSSStyleSheet> pageStyleSheet, TypeBuilder::CSS::StyleSheetOrigin::Enum origin, const String& documentURL, InspectorCSSAgent* cssAgent)
     : InspectorStyleSheetBase(id, cssAgent)
     , m_cssAgent(cssAgent)
     , m_resourceAgent(resourceAgent)
     , m_pageStyleSheet(pageStyleSheet)
@@ skipping 682 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(pageStyleSheet(), &m_flatRules);
 }
 
-bool InspectorStyleSheet::setStyleText(unsigned ruleIndex, const String& text)
-{
-    CSSStyleDeclaration* style = styleAt(ruleIndex);
-    if (!style)
-        return false;
-
-    if (!ensureParsedDataReady())
-        return false;
-
-    String patchedStyleSheetText;
-    bool success = styleSheetTextWithChangedStyle(style, text, &patchedStyleSheetText);
-    if (!success)
-        return false;
-
-    TrackExceptionState exceptionState;
-    style->setCSSText(text, exceptionState);
-    if (!exceptionState.hadException()) {
-        innerSetText(patchedStyleSheetText);
-        onStyleSheetTextChanged();
-    }
-
-    return !exceptionState.hadException();
-}
-
-bool InspectorStyleSheet::styleSheetTextWithChangedStyle(CSSStyleDeclaration* style, const String& newStyleText, String* result)
-{
-    if (!style)
-        return false;
-
-    unsigned ruleIndex = indexOf(style);
-    if (!ensureParsedDataReady() || ruleIndex == UINT_MAX)
-        return false;
-
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = ruleSourceDataAt(ruleIndex);
-    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
-
-    text.replace(bodyStart, bodyEnd - bodyStart, newStyleText);
-    *result = text;
-    return true;
-}
-
 unsigned InspectorStyleSheet::indexOf(CSSStyleRule* rule) const
 {
     return indexOf(rule->style());
 }
 
 bool InspectorStyleSheet::originalStyleSheetText(String* result) const
 {
     bool success = inlineStyleSheetText(result);
     if (!success)
         success = resourceStyleSheetText(result);
@@ skipping 64 matching lines @@
     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)
-{
-    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();
     }
     return !exceptionState.hadException();
 }
 
+bool InspectorStyleSheetForInlineStyle::getText(String* result) const
+{
+    if (!m_isStyleTextValid) {
+        m_styleText = elementStyleText();
+        m_isStyleTextValid = true;
+    }
+    *result = m_styleText;
+    return true;
+}
+
 Document* InspectorStyleSheetForInlineStyle::ownerDocument() const
 {
     return &m_element->document();
 }
 
 bool InspectorStyleSheetForInlineStyle::ensureParsedDataReady()
 {
     // The "style" property value can get changed indirectly, e.g. via element.style.borderWidth = "2px".
     const String& currentStyleText = elementStyleText();
     if (m_styleText != currentStyleText) {
@@ skipping 52 matching lines @@
 
 DEFINE_TRACE(InspectorStyleSheetForInlineStyle)
 {
     visitor->trace(m_element);
     visitor->trace(m_ruleSourceData);
     visitor->trace(m_inspectorStyle);
     InspectorStyleSheetBase::trace(visitor);
 }
 
 } // namespace blink