DevTools: explicitly map CSSOM rules to source ranges.

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 434 matching lines @@
         case StyleRule::Supports:
             result->append(data);
             flattenSourceData(&data->childRules, result);
             break;
         default:
             break;
         }
     }
 }
 
+PassRefPtrWillBeRawPtr<CSSRuleList> asCSSRuleList(CSSRule* rule)
+{
+    if (!rule)
+        return nullptr;
+
+    if (rule->type() == CSSRule::MEDIA_RULE)
+        return toCSSMediaRule(rule)->cssRules();
+
+    if (rule->type() == CSSRule::SUPPORTS_RULE)
+        return toCSSSupportsRule(rule)->cssRules();
+
+    return nullptr;
+}
+
+template <typename RuleList>
+void collectFlatRules(RuleList ruleList, CSSRuleVector* result)
+{
+    if (!ruleList)
+        return;
+
+    for (unsigned i = 0, size = ruleList->length(); i < size; ++i) {
+        CSSRule* rule = ruleList->item(i);
+
+        // The result->append()'ed types should be exactly the same as in flattenSourceData().
+        switch (rule->type()) {
+        case CSSRule::STYLE_RULE:
+        case CSSRule::IMPORT_RULE:
+        case CSSRule::CHARSET_RULE:
+        case CSSRule::PAGE_RULE:
+        case CSSRule::FONT_FACE_RULE:
+        case CSSRule::VIEWPORT_RULE:
+        case CSSRule::KEYFRAMES_RULE:
+            result->append(rule);
+            break;
+        case CSSRule::MEDIA_RULE:
+        case CSSRule::SUPPORTS_RULE:
+            result->append(rule);
+            collectFlatRules(asCSSRuleList(rule), result);
+            break;
+        default:
+            break;
+        }
+    }
+}
+
 } // namespace
 
 namespace blink {
 
 enum MediaListSource {
     MediaListSourceLinkedSheet,
     MediaListSourceInlineSheet,
     MediaListSourceMediaRule,
     MediaListSourceImportRule
 };
 
 static PassRefPtr<TypeBuilder::CSS::SourceRange> buildSourceRangeObject(const SourceRange& range, const LineEndings* lineEndings)
 {
     if (!lineEndings)
         return nullptr;
     TextPosition start = TextPosition::fromOffsetAndLineEndings(range.start, *lineEndings);
     TextPosition end = TextPosition::fromOffsetAndLineEndings(range.end, *lineEndings);
 
     RefPtr<TypeBuilder::CSS::SourceRange> result = TypeBuilder::CSS::SourceRange::create()
         .setStartLine(start.m_line.zeroBasedInt())
         .setStartColumn(start.m_column.zeroBasedInt())
         .setEndLine(end.m_line.zeroBasedInt())
         .setEndColumn(end.m_column.zeroBasedInt());
     return result.release();
 }
 
-static PassRefPtrWillBeRawPtr<CSSRuleList> asCSSRuleList(CSSRule* rule)
-{
-    if (!rule)
-        return nullptr;
-
-    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(PassRefPtrWillBeRawPtr<CSSStyleDeclaration> style, PassRefPtrWillBeRawPtr<CSSRuleSourceData> sourceData, InspectorStyleSheetBase* parentStyleSheet)
 {
     return adoptRefWillBeNoop(new InspectorStyle(style, sourceData, parentStyleSheet));
 }
 
 InspectorStyle::InspectorStyle(PassRefPtrWillBeRawPtr<CSSStyleDeclaration> style, PassRefPtrWillBeRawPtr<CSSRuleSourceData> sourceData, InspectorStyleSheetBase* parentStyleSheet)
     : m_style(style)
     , m_sourceData(sourceData)
     , m_parentStyleSheet(parentStyleSheet)
 {
@@ skipping 178 matching lines @@
 
 void InspectorStyleSheetBase::onStyleSheetTextChanged()
 {
     m_lineEndings = adoptPtr(new LineEndings());
     if (listener())
         listener()->styleSheetChanged(this);
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorStyleSheetBase::buildObjectForStyle(CSSStyleDeclaration* style)
 {
-    RefPtrWillBeRawPtr<InspectorStyle> is = inspectorStyle(style);
-    return is->buildObjectForStyle();
+    return inspectorStyle(style)->buildObjectForStyle();
 }
 
 const LineEndings* InspectorStyleSheetBase::lineEndings()
 {
     if (m_lineEndings->size() > 0)
         return m_lineEndings.get();
     String text;
     if (getText(&text))
         m_lineEndings = WTF::lineEndings(text);
     return m_lineEndings.get();
@@ skipping 24 matching lines @@
     , m_pageStyleSheet(pageStyleSheet)
     , m_origin(origin)
     , m_documentURL(documentURL)
 {
     String text;
     bool success = inlineStyleSheetText(&text);
     if (!success)
         success = resourceStyleSheetText(&text);
     if (success)
         innerSetText(text, false);
+    collectFlatRules();
 }
 
 InspectorStyleSheet::~InspectorStyleSheet()
 {
 }
 
 DEFINE_TRACE(InspectorStyleSheet)
 {
     visitor->trace(m_cssAgent);
     visitor->trace(m_resourceAgent);
@@ skipping 12 matching lines @@
 
 String InspectorStyleSheet::finalURL()
 {
     String url = styleSheetURL(m_pageStyleSheet.get());
     return url.isEmpty() ? m_documentURL : url;
 }
 
 bool InspectorStyleSheet::setText(const String& text, ExceptionState& exceptionState)
 {
     innerSetText(text, true);
-    m_flatRules.clear();
 
     if (listener())
         listener()->willReparseStyleSheet();
 
     {
         // Have a separate scope for clearRules() (bug 95324).
         CSSStyleSheet::RuleMutationScope mutationScope(m_pageStyleSheet.get());
         m_pageStyleSheet->contents()->clearRules();
         m_pageStyleSheet->clearChildRuleCSSOMWrappers();
     }
     {
         CSSStyleSheet::RuleMutationScope mutationScope(m_pageStyleSheet.get());
         m_pageStyleSheet->contents()->parseString(text);
     }
 
     if (listener())
         listener()->didReparseStyleSheet();
     onStyleSheetTextChanged();
     m_pageStyleSheet->ownerDocument()->styleResolverChanged(FullStyleUpdate);
+
+    collectFlatRules();
     return true;
 }
 
 RefPtrWillBeRawPtr<CSSStyleRule> InspectorStyleSheet::setRuleSelector(const SourceRange& range, const String& text, SourceRange* newRange, String* oldText, ExceptionState& exceptionState)
 {
     if (!verifySelectorText(m_pageStyleSheet->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) {
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = findRuleByHeaderRange(range);
+    if (!sourceData || !sourceData->styleSourceData) {
         exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing source range");
         return nullptr;
     }
 
-    RefPtrWillBeRawPtr<CSSStyleRule>  styleRule = InspectorCSSAgent::asCSSStyleRule(rule);
+    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(sourceData.get());
+    if (!rule || !rule->parentStyleSheet() || 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.get());
     styleRule->setSelectorText(text);
 
     replaceText(sourceData->ruleHeaderRange, text, newRange, oldText);
     onStyleSheetTextChanged();
 
     return styleRule;
 }
 
 RefPtrWillBeRawPtr<CSSStyleRule> InspectorStyleSheet::setStyleText(const SourceRange& range, const String& text, SourceRange* newRange, String* oldText, ExceptionState& exceptionState)
 {
     if (!verifyStyleText(m_pageStyleSheet->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) {
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = findRuleByBodyRange(range);
+    if (!sourceData || !sourceData->styleSourceData) {
         exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing style source range");
         return nullptr;
     }
 
-    RefPtrWillBeRawPtr<CSSStyleRule> styleRule = InspectorCSSAgent::asCSSStyleRule(rule);
+    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(sourceData.get());
+    if (!rule || !rule->parentStyleSheet() || 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.get());
     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(m_pageStyleSheet->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) {
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = findRuleByHeaderRange(range);
+    if (!sourceData || !sourceData->mediaSourceData) {
         exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing source range");
         return nullptr;
     }
 
-    RefPtrWillBeRawPtr<CSSMediaRule>  mediaRule = InspectorCSSAgent::asCSSMediaRule(rule);
+    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(sourceData.get());
+    if (!rule || !rule->parentStyleSheet() || rule->type() != CSSRule::MEDIA_RULE) {
+        exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing style source range");
+        return nullptr;
+    }
+
+    RefPtrWillBeRawPtr<CSSMediaRule>  mediaRule = InspectorCSSAgent::asCSSMediaRule(rule.get());
     mediaRule->media()->setMediaText(text);
 
     replaceText(sourceData->ruleHeaderRange, text, newRange, oldText);
     onStyleSheetTextChanged();
 
     return mediaRule;
 }
 
-unsigned InspectorStyleSheet::ruleIndexBySourceRange(const CSSMediaRule* parentMediaRule, const SourceRange& sourceRange)
+unsigned InspectorStyleSheet::ruleIndexBySourceRange(CSSMediaRule* parentMediaRule, const SourceRange& sourceRange)
 {
     ASSERT(m_sourceData);
     unsigned index = 0;
     for (size_t i = 0; i < m_flatRules.size() && i < m_sourceData->size(); ++i) {
         RefPtrWillBeRawPtr<CSSRule> rule = m_flatRules.at(i);
         if (rule->parentRule() != parentMediaRule)
             continue;
         RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_sourceData->at(i);
         if (ruleSourceData->ruleBodyRange.end < sourceRange.start)
             ++index;
@@ skipping 44 matching lines @@
         if (sourceRange.start < ruleSourceData->ruleBodyRange.start || ruleSourceData->ruleBodyRange.end < sourceRange.start)
             continue;
         if (containingRuleIndex == -1 || containingRuleLength > ruleSourceData->ruleBodyRange.length()) {
             containingRuleIndex = i;
             containingRuleLength = ruleSourceData->ruleBodyRange.length();
         }
     }
     if (containingRuleIndex == -1)
         return insertCSSOMRuleInStyleSheet(sourceRange, ruleText, exceptionState);
 
-    RefPtrWillBeRawPtr<CSSRule> rule = m_flatRules.at(containingRuleIndex);
-    if (rule->type() != CSSRule::MEDIA_RULE) {
+    RefPtrWillBeRawPtr<CSSRule> rule = containingRuleIndex < static_cast<int>(m_flatRules.size()) ? m_flatRules.at(containingRuleIndex) : nullptr;
+    if (!rule || 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);
 }
 
 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(m_pageStyleSheet->ownerDocument(), ruleText)) {
         exceptionState.throwDOMException(SyntaxError, "Rule text is not valid.");
         return nullptr;
     }
 
     if (!m_sourceData) {
         exceptionState.throwDOMException(NotFoundError, "Style is read-only.");
         return nullptr;
     }
-    ensureFlatRules();
 
     RefPtrWillBeRawPtr<CSSStyleRule> styleRule = insertCSSOMRuleBySourceRange(location, ruleText, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     replaceText(location, ruleText, addedRange, nullptr);
-    m_flatRules.clear();
+    collectFlatRules();
 
     onStyleSheetTextChanged();
     return styleRule;
 }
 
 bool InspectorStyleSheet::deleteRule(const SourceRange& range, ExceptionState& exceptionState)
 {
     if (!m_sourceData) {
         exceptionState.throwDOMException(NotFoundError, "Style is read-only.");
         return false;
@@ skipping 46 matching lines @@
             ++index;
         ASSERT(index < styleSheet->length());
         styleSheet->deleteRule(index, exceptionState);
     }
     // |rule| MAY NOT be addressed after this line!
 
     if (exceptionState.hadException())
         return false;
 
     replaceText(range, "", nullptr, nullptr);
-    m_flatRules.clear();
+    collectFlatRules();
+
     onStyleSheetTextChanged();
     return true;
 }
 
 void InspectorStyleSheet::replaceText(const SourceRange& range, const String& text, SourceRange* newRange, String* oldText)
 {
     String sheetText = m_text;
     if (oldText)
         *oldText = sheetText.substring(range.start, range.length());
     sheetText.replace(range.start, range.length(), text);
@@ skipping 45 matching lines @@
 
     if (styleSheet->ownerNode())
         result->setOwnerNode(DOMNodeIds::idForNode(styleSheet->ownerNode()));
 
     String sourceMapURLValue = sourceMapURL();
     if (!sourceMapURLValue.isEmpty())
         result->setSourceMapURL(sourceMapURLValue);
     return result.release();
 }
 
-PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::Selector> > InspectorStyleSheet::selectorsFromSource(const CSSRuleSourceData* sourceData, const String& sheetText)
+PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::Selector>> InspectorStyleSheet::selectorsFromSource(CSSRuleSourceData* sourceData, const String& sheetText)
 {
     ScriptRegexp comment("/\\*[^]*?\\*/", TextCaseSensitive, MultilineEnabled);
     RefPtr<TypeBuilder::Array<TypeBuilder::CSS::Selector> > result = TypeBuilder::Array<TypeBuilder::CSS::Selector>::create();
     const SelectorRangeList& ranges = sourceData->selectorRanges;
     for (size_t i = 0, size = ranges.size(); i < size; ++i) {
         const SourceRange& range = ranges.at(i);
         String selector = sheetText.substring(range.start, range.length());
 
         // We don't want to see any comments in the selector components, only the meaningful parts.
         int matchLength;
         int offset = 0;
         while ((offset = comment.match(selector, offset, &matchLength)) >= 0)
             selector.replace(offset, matchLength, "");
 
         RefPtr<TypeBuilder::CSS::Selector> simpleSelector = TypeBuilder::CSS::Selector::create()
             .setValue(selector.stripWhiteSpace());
         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 && m_sourceData && ruleIndex < m_sourceData->size())
-        sourceData = m_sourceData->at(ruleIndex);
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = sourceDataForRule(rule);
     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)
+    if (sourceData) {
         selectors = selectorsFromSource(sourceData.get(), m_text);
-    else {
+    } else {
         selectors = TypeBuilder::Array<TypeBuilder::CSS::Selector>::create();
         const CSSSelectorList& selectorList = rule->styleRule()->selectorList();
         for (const CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(*selector))
             selectors->addItem(TypeBuilder::CSS::Selector::create().setValue(selector->selectorText()).release());
     }
     RefPtr<TypeBuilder::CSS::SelectorList> result = TypeBuilder::CSS::SelectorList::create()
         .setSelectors(selectors)
         .setText(selectorText)
         .release();
     return result.release();
@@ skipping 28 matching lines @@
 
 bool InspectorStyleSheet::getText(String* result)
 {
     if (m_sourceData) {
         *result = m_text;
         return true;
     }
     return false;
 }
 
-PassRefPtr<TypeBuilder::CSS::SourceRange> InspectorStyleSheet::ruleHeaderSourceRange(const CSSRule* rule)
+PassRefPtr<TypeBuilder::CSS::SourceRange> InspectorStyleSheet::ruleHeaderSourceRange(CSSRule* rule)
 {
     if (!m_sourceData)
         return nullptr;
-
-    ensureFlatRules();
-    size_t index = m_flatRules.find(rule);
-    // FIXME(lusnikov): m_flatRules are not always aligned with the m_sourceData rule source
-    // datas due to the CSSOM operations that add/remove rules without changing source.
-    // This is a design issue. See crbug.com/178410
-    if (index == kNotFound || index >= m_sourceData->size())
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = sourceDataForRule(rule);
+    if (!sourceData)
         return nullptr;
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = m_sourceData->at(static_cast<unsigned>(index));
     return buildSourceRangeObject(sourceData->ruleHeaderRange, lineEndings());
 }
 
-PassRefPtr<TypeBuilder::CSS::SourceRange> InspectorStyleSheet::mediaQueryExpValueSourceRange(const CSSRule* rule, size_t mediaQueryIndex, size_t mediaQueryExpIndex)
+PassRefPtr<TypeBuilder::CSS::SourceRange> InspectorStyleSheet::mediaQueryExpValueSourceRange(CSSRule* rule, size_t mediaQueryIndex, size_t mediaQueryExpIndex)
 {
     if (!m_sourceData)
         return nullptr;
-    ensureFlatRules();
-    size_t index = m_flatRules.find(rule);
-    if (index == kNotFound || index >= m_sourceData->size())
-        return nullptr;
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = m_sourceData->at(static_cast<unsigned>(index));
-    if (!sourceData->mediaSourceData || mediaQueryIndex >= sourceData->mediaSourceData->queryData.size())
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = sourceDataForRule(rule);
+    if (!sourceData || !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::inspectorStyle(RefPtrWillBeRawPtr<CSSStyleDeclaration> style)
 {
-    if (!style)
-        return nullptr;
-
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = nullptr;
-    unsigned ruleIndex = indexOf(style.get());
-    if (ruleIndex != UINT_MAX && m_sourceData && ruleIndex < m_sourceData->size())
-        sourceData = m_sourceData->at(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);
+    return style ? InspectorStyle::create(style, sourceDataForRule(style->parentRule()), this) : nullptr;
 }
 
 String InspectorStyleSheet::sourceURL()
 {
     if (!m_sourceURL.isNull())
         return m_sourceURL;
     if (m_origin != TypeBuilder::CSS::StyleSheetOrigin::Regular) {
         m_sourceURL = "";
         return m_sourceURL;
     }
@@ skipping 57 matching lines @@
         bool deprecated;
         String commentValue = ContentSearchUtils::findSourceMapURL(styleSheetText, ContentSearchUtils::CSSMagicComment, &deprecated);
         if (!commentValue.isEmpty()) {
             // FIXME: add deprecated console message here.
             return commentValue;
         }
     }
     return m_pageStyleSheet->contents()->sourceMapURL();
 }
 
-unsigned InspectorStyleSheet::indexOf(CSSStyleDeclaration* style)
+RefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyleSheet::findRuleByHeaderRange(const SourceRange& sourceRange)
 {
-    ensureFlatRules();
-    for (unsigned i = 0, size = m_flatRules.size(); i < size; ++i) {
-        CSSStyleRule* styleRule = InspectorCSSAgent::asCSSStyleRule(m_flatRules.at(i).get());
-        if (styleRule && styleRule->style() == style)
-            return i;
+    if (!m_sourceData)
+        return nullptr;
+
+    for (size_t i = 0; i < m_sourceData->size(); ++i) {
+        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_sourceData->at(i);
+        if (ruleSourceData->ruleHeaderRange.start == sourceRange.start && ruleSourceData->ruleHeaderRange.end == sourceRange.end) {
+            return ruleSourceData;
+        }
     }
-    return UINT_MAX;
+    return nullptr;
 }
 
-bool InspectorStyleSheet::findRuleByHeaderRange(const SourceRange& sourceRange, CSSRule** pRule, CSSRuleSourceData** pSourceData)
+RefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyleSheet::findRuleByBodyRange(const SourceRange& sourceRange)
 {
     if (!m_sourceData)
-        return false;
-    ensureFlatRules();
+        return nullptr;
 
-    for (size_t i = 0; i < m_sourceData->size() && i < m_flatRules.size(); ++i) {
+    for (size_t i = 0; i < m_sourceData->size(); ++i) {
         RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_sourceData->at(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;
+        if (ruleSourceData->ruleBodyRange.start == sourceRange.start && ruleSourceData->ruleBodyRange.end == sourceRange.end) {
+            return ruleSourceData;
         }
     }
-    return false;
+    return nullptr;
 }
 
-bool InspectorStyleSheet::findRuleByBodyRange(const SourceRange& sourceRange, CSSRule** pRule, CSSRuleSourceData** pSourceData)
+RefPtrWillBeRawPtr<CSSRule> InspectorStyleSheet::ruleForSourceData(CSSRuleSourceData* sourceData)
 {
     if (!m_sourceData)
-        return false;
-    ensureFlatRules();
+        return nullptr;
+    for (size_t i = 0; i < m_sourceData->size(); ++i) {
+        if (m_sourceData->at(i).get() == sourceData)
+            return i < m_flatRules.size() ? m_flatRules.at(i) : nullptr;
+    }
+    return nullptr;
+}
 
-    for (size_t i = 0; i < m_sourceData->size() && i < m_flatRules.size(); ++i) {
-        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_sourceData->at(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;
+RefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyleSheet::sourceDataForRule(CSSRule* rule)
+{
+    if (!m_sourceData || !rule)
+        return nullptr;
+
+    size_t index = m_flatRules.find(rule);
+    return index < m_sourceData->size() ? m_sourceData->at(index) : nullptr;
+}
+
+void InspectorStyleSheet::collectFlatRules()
+{
+    m_flatRules.clear();
+    ::collectFlatRules(m_pageStyleSheet.get(), &m_flatRules);
 }
 
 const CSSRuleVector& InspectorStyleSheet::flatRules()
 {
-    ensureFlatRules();
     return m_flatRules;
 }
 
-template <typename RuleList>
-static void collectFlatRules(RuleList ruleList, CSSRuleVector* result)
-{
-    if (!ruleList)
-        return;
-
-    for (unsigned i = 0, size = ruleList->length(); i < size; ++i) {
-        CSSRule* rule = ruleList->item(i);
-
-        // The result->append()'ed types should be exactly the same as in flattenSourceData().
-        switch (rule->type()) {
-        case CSSRule::STYLE_RULE:
-        case CSSRule::IMPORT_RULE:
-        case CSSRule::CHARSET_RULE:
-        case CSSRule::PAGE_RULE:
-        case CSSRule::FONT_FACE_RULE:
-        case CSSRule::VIEWPORT_RULE:
-        case CSSRule::KEYFRAMES_RULE:
-            result->append(rule);
-            break;
-        case CSSRule::MEDIA_RULE:
-        case CSSRule::SUPPORTS_RULE:
-            result->append(rule);
-            collectFlatRules(asCSSRuleList(rule), result);
-            break;
-        default:
-            break;
-        }
-    }
-}
-
-void InspectorStyleSheet::ensureFlatRules()
-{
-    // We are fine with redoing this for empty stylesheets as this will run fast.
-    if (m_flatRules.isEmpty())
-        collectFlatRules(pageStyleSheet(), &m_flatRules);
-}
-
 bool InspectorStyleSheet::resourceStyleSheetText(String* result)
 {
     if (m_origin == TypeBuilder::CSS::StyleSheetOrigin::Injected || m_origin == TypeBuilder::CSS::StyleSheetOrigin::User_agent)
         return false;
 
     if (!m_pageStyleSheet->ownerDocument())
         return false;
 
     KURL url(ParsedURLString, m_pageStyleSheet->href());
     if (m_cssAgent->getEditedStyleSheet(url, result))
@@ skipping 97 matching lines @@
 }
 
 DEFINE_TRACE(InspectorStyleSheetForInlineStyle)
 {
     visitor->trace(m_element);
     visitor->trace(m_inspectorStyle);
     InspectorStyleSheetBase::trace(visitor);
 }
 
 } // namespace blink