DevTools: remove ruleId from the style.

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 559 matching lines @@
 
     if (rule->type() == CSSRule::MEDIA_RULE)
         return toCSSMediaRule(rule)->cssRules();
 
     if (rule->type() == CSSRule::SUPPORTS_RULE)
         return toCSSSupportsRule(rule)->cssRules();
 
     return nullptr;
 }
 
-PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyle::create(unsigned ruleIndex, PassRefPtrWillBeRawPtr<CSSStyleDeclaration> style, InspectorStyleSheetBase* parentStyleSheet)
+PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyle::create(PassRefPtrWillBeRawPtr<CSSStyleDeclaration> style, PassRefPtrWillBeRawPtr<CSSRuleSourceData> sourceData, InspectorStyleSheetBase* parentStyleSheet)
 {
-    return adoptRefWillBeNoop(new InspectorStyle(ruleIndex, style, parentStyleSheet));
+    return adoptRefWillBeNoop(new InspectorStyle(style, sourceData, parentStyleSheet));
 }
 
-InspectorStyle::InspectorStyle(unsigned ruleIndex, PassRefPtrWillBeRawPtr<CSSStyleDeclaration> style, InspectorStyleSheetBase* parentStyleSheet)
-    : m_ruleIndex(ruleIndex)
-    , m_style(style)
+InspectorStyle::InspectorStyle(PassRefPtrWillBeRawPtr<CSSStyleDeclaration> style, PassRefPtrWillBeRawPtr<CSSRuleSourceData> sourceData, InspectorStyleSheetBase* parentStyleSheet)
+    : m_style(style)
+    , m_sourceData(sourceData)
     , m_parentStyleSheet(parentStyleSheet)
 {
     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());
 
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = extractSourceData();
-    if (sourceData)
-        result->setRange(buildSourceRangeObject(sourceData->ruleBodyRange, m_parentStyleSheet->lineEndings()));
+    if (m_sourceData) {
+        result->setRange(buildSourceRangeObject(m_sourceData->ruleBodyRange, m_parentStyleSheet->lineEndings()));
+        String sheetText;
+        bool success = m_parentStyleSheet->getText(&sheetText);
+        if (success) {
+            const SourceRange& bodyRange = m_sourceData->ruleBodyRange;
+            result->setCssText(sheetText.substring(bodyRange.start, bodyRange.end - bodyRange.start));
+        }
+    }
 
     return result.release();
 }
 
 PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSComputedStyleProperty> > InspectorStyle::buildArrayForComputedStyle() const
 {
     RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSComputedStyleProperty> > result = TypeBuilder::Array<TypeBuilder::CSS::CSSComputedStyleProperty>::create();
-    WillBeHeapVector<InspectorStyleProperty> properties;
+    WillBeHeapVector<CSSPropertySourceData> properties;
     populateAllProperties(properties);
 
     for (auto& property : properties) {
-        const CSSPropertySourceData& propertyEntry = property.sourceData;
         RefPtr<TypeBuilder::CSS::CSSComputedStyleProperty> entry = TypeBuilder::CSS::CSSComputedStyleProperty::create()
-            .setName(propertyEntry.name)
-            .setValue(propertyEntry.value);
+            .setName(property.name)
+            .setValue(property.value);
         result->addItem(entry);
     }
 
     return result.release();
 }
 
 bool InspectorStyle::styleText(String* result) const
 {
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = extractSourceData();
-    if (!sourceData)
+    if (!m_sourceData)
         return false;
 
-    return textForRange(sourceData->ruleBodyRange, result);
+    return textForRange(m_sourceData->ruleBodyRange, result);
 }
 
 bool InspectorStyle::textForRange(const SourceRange& range, String* result) const
 {
     String styleSheetText;
     bool success = m_parentStyleSheet->getText(&styleSheetText);
     if (!success)
         return false;
 
     ASSERT(0 <= range.start);
     ASSERT(range.start <= range.end);
     ASSERT(range.end <= styleSheetText.length());
     *result = styleSheetText.substring(range.start, range.end - range.start);
     return true;
 }
 
-void InspectorStyle::populateAllProperties(WillBeHeapVector<InspectorStyleProperty>& result) const
+void InspectorStyle::populateAllProperties(WillBeHeapVector<CSSPropertySourceData>& result) const
 {
     HashSet<String> sourcePropertyNames;
 
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = extractSourceData();
-    if (sourceData && sourceData->styleSourceData) {
-        WillBeHeapVector<CSSPropertySourceData>& sourcePropertyData = sourceData->styleSourceData->propertyData;
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = m_sourceData;

[lushnikov, 2015/06/23 10:26:10]

unused

+    if (m_sourceData && m_sourceData->styleSourceData) {
+        WillBeHeapVector<CSSPropertySourceData>& sourcePropertyData = m_sourceData->styleSourceData->propertyData;
         for (const auto& data : sourcePropertyData) {
-            InspectorStyleProperty p(data, true);
-            bool isPropertyTextKnown = textForRange(p.sourceData.range, &p.rawText);
-            ASSERT_UNUSED(isPropertyTextKnown, isPropertyTextKnown);
-            result.append(p);
+            result.append(data);
             sourcePropertyNames.add(data.name.lower());
         }
     }
 
     for (int i = 0, size = m_style->length(); i < size; ++i) {
         String name = m_style->item(i);
         if (!sourcePropertyNames.add(name.lower()).isNewEntry)
             continue;
 
         String value = m_style->getPropertyValue(name);
         if (value.isEmpty())
             continue;
-        result.append(InspectorStyleProperty(CSSPropertySourceData(name, value, !m_style->getPropertyPriority(name).isEmpty(), false, true, SourceRange()), false));
+        result.append(CSSPropertySourceData(name, value, !m_style->getPropertyPriority(name).isEmpty(), false, true, SourceRange()));
     }
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorStyle::styleWithProperties() const
 {
     RefPtr<Array<TypeBuilder::CSS::CSSProperty> > propertiesObject = Array<TypeBuilder::CSS::CSSProperty>::create();
     RefPtr<Array<TypeBuilder::CSS::ShorthandEntry> > shorthandEntries = Array<TypeBuilder::CSS::ShorthandEntry>::create();
     HashSet<String> foundShorthands;
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = extractSourceData();
 
-    WillBeHeapVector<InspectorStyleProperty> properties;
+    WillBeHeapVector<CSSPropertySourceData> properties;
     populateAllProperties(properties);
 
     for (auto& styleProperty : properties) {
-        const CSSPropertySourceData& propertyEntry = styleProperty.sourceData;
+        const CSSPropertySourceData& propertyEntry = styleProperty;
         const String& name = propertyEntry.name;
 
         RefPtr<TypeBuilder::CSS::CSSProperty> property = TypeBuilder::CSS::CSSProperty::create()
             .setName(name)
             .setValue(propertyEntry.value);
         propertiesObject->addItem(property);
 
         // Default "parsedOk" == true.
         if (!propertyEntry.parsedOk)
             property->setParsedOk(false);
-        if (styleProperty.hasRawText())
-            property->setText(styleProperty.rawText);
-
+        String text;
+        if (styleProperty.range.length() && textForRange(styleProperty.range, &text))
+            property->setText(text);
         if (propertyEntry.important)
             property->setImportant(true);
-        if (styleProperty.hasSource) {
+        if (styleProperty.range.length()) {
             property->setRange(buildSourceRangeObject(propertyEntry.range, m_parentStyleSheet ? m_parentStyleSheet->lineEndings() : nullptr));
             if (!propertyEntry.disabled) {
-                ASSERT_UNUSED(sourceData, sourceData);
                 property->setImplicit(false);
             }
             property->setDisabled(propertyEntry.disabled);
         } else if (!propertyEntry.disabled) {
             bool implicit = m_style->isPropertyImplicit(name);
             // Default "implicit" == false.
             if (implicit)
                 property->setImplicit(true);
 
             String shorthand = m_style->getPropertyShorthand(name);
             if (!shorthand.isEmpty()) {
                 if (foundShorthands.add(shorthand).isNewEntry) {
                     RefPtr<TypeBuilder::CSS::ShorthandEntry> entry = TypeBuilder::CSS::ShorthandEntry::create()
                         .setName(shorthand)
                         .setValue(shorthandValue(shorthand));
                     shorthandEntries->addItem(entry);
                 }
             }
         }
     }
 
     RefPtr<TypeBuilder::CSS::CSSStyle> result = TypeBuilder::CSS::CSSStyle::create()
         .setCssProperties(propertiesObject)
         .setShorthandEntries(shorthandEntries);
     return result.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyle::extractSourceData() const
-{
-    if (m_ruleIndex == UINT_MAX || !m_parentStyleSheet || !m_parentStyleSheet->ensureParsedDataReady())
-        return nullptr;
-    return m_parentStyleSheet->ruleSourceDataAt(m_ruleIndex);
-}
-
 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 12 matching lines @@
     return value;
 }
 
 Document* InspectorStyle::ownerDocument() const
 {
     return m_parentStyleSheet->ownerDocument();
 }
 
 DEFINE_TRACE(InspectorStyle)
 {
+    visitor->trace(m_sourceData);
     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()))
 {
 }
 
 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;
-    unsigned ruleIndex = indexOf(style);
-    if (ruleIndex != UINT_MAX && ensureParsedDataReady())
-        sourceData = ruleSourceDataAt(ruleIndex);
-
-    if (ruleIndex == UINT_MAX) {
-        // Any rule coming from User Agent and not from DefaultStyleSheet will not have id.
-        // See InspectorCSSAgent::buildObjectForRule for details.
-        RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = InspectorStyle::create(UINT_MAX, style, this);
-        return inspectorStyle->buildObjectForStyle();
-    }
-    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = inspectorStyleAt(ruleIndex);
-    RefPtr<TypeBuilder::CSS::CSSStyle> result = inspectorStyle->buildObjectForStyle();
-
-    // Style text cannot be retrieved without stylesheet, so set cssText here.
-    if (sourceData) {
-        String sheetText;
-        bool success = getText(&sheetText);
-        if (success) {
-            const SourceRange& bodyRange = sourceData->ruleBodyRange;
-            result->setCssText(sheetText.substring(bodyRange.start, bodyRange.end - bodyRange.start));
-        }
-    }
-
+    RefPtrWillBeRawPtr<InspectorStyle> is = inspectorStyle(style);
+    RefPtr<TypeBuilder::CSS::CSSStyle> result = is->buildObjectForStyle();
     return result.release();
 }
 
 const LineEndings* InspectorStyleSheetBase::lineEndings()
 {
     if (m_lineEndings->size() > 0)
         return m_lineEndings.get();
     String text;
     if (getText(&text))
         m_lineEndings = WTF::lineEndings(text);
@@ skipping 398 matching lines @@
         simpleSelector->setRange(buildSourceRangeObject(range, lineEndings()));
         result->addItem(simpleSelector.release());
     }
     return result.release();
 }
 
 PassRefPtr<TypeBuilder::CSS::SelectorList> InspectorStyleSheet::buildObjectForSelectorList(CSSStyleRule* rule)
 {
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = nullptr;
     unsigned ruleIndex = indexOf(rule->style());
-    if (ruleIndex != UINT_MAX && ensureParsedDataReady())
-        sourceData = ruleSourceDataAt(ruleIndex);
+    if (ruleIndex != UINT_MAX && ensureParsedDataReady()) {
+        sourceData = m_parsedStyleSheet->ruleSourceDataAt(ruleIndex);
+    }
     RefPtr<TypeBuilder::Array<TypeBuilder::CSS::Selector> > selectors;
 
     // This intentionally does not rely on the source data to avoid catching the trailing comments (before the declaration starting '{').
     String selectorText = rule->selectorText();
 
     if (sourceData)
         selectors = selectorsFromSource(sourceData.get(), m_parsedStyleSheet->text());
     else {
         selectors = TypeBuilder::Array<TypeBuilder::CSS::Selector>::create();
         const CSSSelectorList& selectorList = rule->styleRule()->selectorList();
@@ skipping 77 matching lines @@
         return nullptr;
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = m_parsedStyleSheet->ruleSourceDataAt(static_cast<unsigned>(index));
     if (!sourceData->mediaSourceData || mediaQueryIndex >= sourceData->mediaSourceData->queryData.size())
         return nullptr;
     RefPtrWillBeRawPtr<CSSMediaQuerySourceData> mediaQueryData = sourceData->mediaSourceData->queryData.at(mediaQueryIndex);
     if (mediaQueryExpIndex >= mediaQueryData->expData.size())
         return nullptr;
     return buildSourceRangeObject(mediaQueryData->expData.at(mediaQueryExpIndex).valueRange, lineEndings());
 }
 
-PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyleSheet::inspectorStyleAt(unsigned ruleIndex)
+PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyleSheet::inspectorStyle(RefPtrWillBeRawPtr<CSSStyleDeclaration> style)
 {
-    CSSStyleDeclaration* style = styleAt(ruleIndex);
     if (!style)
         return nullptr;
 
-    return InspectorStyle::create(ruleIndex, style, this);
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = nullptr;
+    unsigned ruleIndex = indexOf(style.get());
+    if (ruleIndex != UINT_MAX && ensureParsedDataReady())
+        sourceData = m_parsedStyleSheet->ruleSourceDataAt(ruleIndex);
+
+    if (ruleIndex == UINT_MAX) {
+        // Any rule coming from User Agent and not from DefaultStyleSheet will not have id.
+        // See InspectorCSSAgent::buildObjectForRule for details.
+        return InspectorStyle::create(style, nullptr, this);
+    }
+
+    return InspectorStyle::create(style, sourceData, this);
 }
 
 unsigned InspectorStyleSheet::ruleCount()
 {
     return m_parsedStyleSheet->ruleCount();
 }
 
 String InspectorStyleSheet::sourceURL() const
 {
     if (!m_sourceURL.isNull())
@@ skipping 80 matching lines @@
     return UINT_MAX;
 }
 
 bool InspectorStyleSheet::findRuleByHeaderRange(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);
+        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_parsedStyleSheet->ruleSourceDataAt(i);
         if (ruleSourceData->ruleHeaderRange.start == sourceRange.start && ruleSourceData->ruleHeaderRange.end == sourceRange.end) {
             *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);
+        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_parsedStyleSheet->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();
 }
 
-PassRefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyleSheet::ruleSourceDataAt(unsigned ruleIndex) const
-{
-    return m_parsedStyleSheet->ruleSourceDataAt(ruleIndex);
-}
-
 bool InspectorStyleSheet::ensureParsedDataReady()
 {
     return ensureText() && m_parsedStyleSheet->ensureSourceData();
 }
 
 bool InspectorStyleSheet::ensureText() const
 {
     if (m_parsedStyleSheet->hasText())
         return true;
 
@@ skipping 98 matching lines @@
 }
 
 PassRefPtrWillBeRawPtr<InspectorStyleSheetForInlineStyle> InspectorStyleSheetForInlineStyle::create(const String& id, PassRefPtrWillBeRawPtr<Element> element, Listener* listener)
 {
     return adoptRefWillBeNoop(new InspectorStyleSheetForInlineStyle(id, element, listener));
 }
 
 InspectorStyleSheetForInlineStyle::InspectorStyleSheetForInlineStyle(const String& id, PassRefPtrWillBeRawPtr<Element> element, Listener* listener)
     : InspectorStyleSheetBase(id, listener)
     , m_element(element)
-    , m_ruleSourceData(nullptr)
-    , m_isStyleTextValid(false)
 {
     ASSERT(m_element);
-    m_inspectorStyle = InspectorStyle::create(0, inlineStyle(), this);
-    m_styleText = m_element->isStyledElement() ? m_element->getAttribute("style").string() : String();
 }
 
 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();
+    m_inspectorStyle.clear();
 }
 
 bool InspectorStyleSheetForInlineStyle::setText(const String& text, ExceptionState& exceptionState)
 {
     if (!verifyStyleText(ownerDocument(), text)) {
         exceptionState.throwDOMException(SyntaxError, "Style text is not valid.");
         return false;
     }
 
     {
         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();
+    if (!exceptionState.hadException())
         onStyleSheetTextChanged();
-    }
     return !exceptionState.hadException();
 }
 
 bool InspectorStyleSheetForInlineStyle::getText(String* result) const
 {
-    if (!m_isStyleTextValid) {
-        m_styleText = elementStyleText();
-        m_isStyleTextValid = true;
-    }
-    *result = m_styleText;
+    *result = elementStyleText();
     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) {
-        m_ruleSourceData.clear();
-        m_styleText = currentStyleText;
-        m_isStyleTextValid = true;
-    }
-
-    if (m_ruleSourceData)
-        return true;
-
-    m_ruleSourceData = getStyleAttributeData();
-
-    bool success = !!m_ruleSourceData;
-    if (!success) {
-        m_ruleSourceData = CSSRuleSourceData::create(StyleRule::Style);
-        return false;
-    }
-
     return true;
 }
 
-PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyleSheetForInlineStyle::inspectorStyleAt(unsigned ruleIndex)
+PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyleSheetForInlineStyle::inspectorStyle(RefPtrWillBeRawPtr<CSSStyleDeclaration> style)
 {
-    ASSERT_UNUSED(ruleIndex, !ruleIndex);
+    if (!m_inspectorStyle) {
+        const String& text = elementStyleText();
+        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData;
+        if (text.isEmpty()) {
+            ruleSourceData = CSSRuleSourceData::create(StyleRule::Style);
+            ruleSourceData->ruleBodyRange.start = 0;
+            ruleSourceData->ruleBodyRange.end = 0;
+        } else {
+            RuleSourceDataList ruleSourceDataResult;
+            StyleSheetHandler handler(text, &m_element->document(), &ruleSourceDataResult);
+            CSSParser::parseDeclarationListForInspector(parserContextForDocument(&m_element->document()), text, handler);
+            ruleSourceData = ruleSourceDataResult.first().release();
+        }
+        m_inspectorStyle = InspectorStyle::create(m_element->style(), ruleSourceData, this);
+    }
     return m_inspectorStyle;
 }
 
 CSSStyleDeclaration* InspectorStyleSheetForInlineStyle::inlineStyle() const
 {
     return m_element->style();
 }
 
 const String& InspectorStyleSheetForInlineStyle::elementStyleText() const
 {
     return m_element->getAttribute("style").string();
 }
 
-PassRefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyleSheetForInlineStyle::getStyleAttributeData() const
-{
-    if (!m_element->isStyledElement())
-        return nullptr;
-
-    if (m_styleText.isEmpty()) {
-        RefPtrWillBeRawPtr<CSSRuleSourceData> result = CSSRuleSourceData::create(StyleRule::Style);
-        result->ruleBodyRange.start = 0;
-        result->ruleBodyRange.end = 0;
-        return result.release();
-    }
-
-    RuleSourceDataList ruleSourceDataResult;
-    StyleSheetHandler handler(m_styleText, &m_element->document(), &ruleSourceDataResult);
-    CSSParser::parseDeclarationListForInspector(parserContextForDocument(&m_element->document()), m_styleText, handler);
-    return ruleSourceDataResult.first().release();
-}
-
 DEFINE_TRACE(InspectorStyleSheetForInlineStyle)
 {
     visitor->trace(m_element);
-    visitor->trace(m_ruleSourceData);
     visitor->trace(m_inspectorStyle);
     InspectorStyleSheetBase::trace(visitor);
 }
 
 } // namespace blink