DevTools: allow injecting CSS rules without breaking styles sidebar.

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 11 matching lines @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/inspector/InspectorStyleSheet.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "bindings/core/v8/ScriptRegexp.h"
 #include "core/CSSPropertyNames.h"
+#include "core/css/CSSImportRule.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSMediaRule.h"
 #include "core/css/CSSRuleList.h"
 #include "core/css/CSSStyleRule.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/CSSSupportsRule.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/parser/CSSParser.h"
@@ skipping 286 matching lines @@
 }
 
 void StyleSheetHandler::endMediaQuery()
 {
     m_currentMediaQueryData.clear();
 }
 
 bool verifyRuleText(Document* document, const String& ruleText)
 {
     DEFINE_STATIC_LOCAL(String, bogusPropertyName, ("-webkit-boguz-propertee"));
+    RefPtrWillBeRawPtr<StyleSheetContents> styleSheet = StyleSheetContents::create(strictCSSParserContext());
     RuleSourceDataList sourceData;
     String text = ruleText + " div { " + bogusPropertyName + ": none; }";
     StyleSheetHandler handler(text, document, &sourceData);
-    CSSParser::parseSheetForInspector(parserContextForDocument(document), text, handler);
+    CSSParser::parseSheetForInspector(parserContextForDocument(document), styleSheet.get(), 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;
 
@@ skipping 12 matching lines @@
 }
 
 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"));
+    RefPtrWillBeRawPtr<StyleSheetContents> styleSheet = StyleSheetContents::create(strictCSSParserContext());
     RuleSourceDataList sourceData;
     String text = selectorText + " { " + bogusPropertyName + ": none; }";
     StyleSheetHandler handler(text, document, &sourceData);
-    CSSParser::parseSheetForInspector(parserContextForDocument(document), text, handler);
+    CSSParser::parseSheetForInspector(parserContextForDocument(document), styleSheet.get(), 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"));
+    RefPtrWillBeRawPtr<StyleSheetContents> styleSheet = StyleSheetContents::create(strictCSSParserContext());
     RuleSourceDataList sourceData;
     String text = "@media " + mediaText + " { div { " + bogusPropertyName + ": none; } }";
     StyleSheetHandler handler(text, document, &sourceData);
-    CSSParser::parseSheetForInspector(parserContextForDocument(document), text, handler);
+    CSSParser::parseSheetForInspector(parserContextForDocument(document), styleSheet.get(), 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)
@@ skipping 76 matching lines @@
         case CSSRule::SUPPORTS_RULE:
             result->append(rule);
             collectFlatRules(asCSSRuleList(rule), result);
             break;
         default:
             break;
         }
     }
 }
 
+typedef HashMap<unsigned, unsigned, WTF::IntHash<unsigned>, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> IndexMap;
+
+void diff(const Vector<String>& listA, const Vector<String>& listB, IndexMap* aToB, IndexMap* bToA)
+{
+    // Cut of common prefix.
+    size_t startOffset = 0;
+    while (startOffset < listA.size() && startOffset < listB.size()) {
+        if (listA.at(startOffset) != listB.at(startOffset))
+            break;
+        aToB->set(startOffset, startOffset);
+        bToA->set(startOffset, startOffset);
+        ++startOffset;
+    }
+
+    // Cut of common suffix.
+    size_t endOffset = 0;
+    while (endOffset < listA.size() - startOffset && endOffset < listB.size() - startOffset) {
+        size_t indexA = listA.size() - endOffset - 1;
+        size_t indexB = listB.size() - endOffset - 1;
+        if (listA.at(indexA) != listB.at(indexB))
+            break;
+        aToB->set(indexA, indexB);
+        bToA->set(indexB, indexA);
+        ++endOffset;
+    }
+
+    int n = listA.size() - startOffset - endOffset;
+    int m = listB.size() - startOffset - endOffset;
+
+    // If we mapped either of arrays, we have no more work to do.
+    if (n == 0 || m == 0)
+        return;
+
+    int** diff = new int*[n];
+    int** backtrack = new int*[n];
+    for (int i = 0; i < n; ++i) {
+        diff[i] = new int[m];
+        backtrack[i] = new int[m];
+    }
+
+    // Compute longest common subsequence of two cssom models.
+    for (int i = 0; i < n; ++i) {
+        for (int j = 0; j < m; ++j) {
+            int max = 0;
+            int track = 0;
+
+            if (i > 0 && diff[i - 1][j] > max) {
+                max = diff[i - 1][j];
+                track = 1;
+            }
+
+            if (j > 0 && diff[i][j - 1] > max) {
+                max = diff[i][j - 1];
+                track = 2;
+            }
+
+            if (listA.at(i + startOffset) == listB.at(j + startOffset)) {
+                int value = i > 0 && j > 0 ? diff[i - 1][j - 1] + 1 : 1;
+                if (value > max) {
+                    max = value;
+                    track = 3;
+                }
+            }
+
+            diff[i][j] = max;
+            backtrack[i][j] = track;
+        }
+    }
+
+    // Backtrack and add missing mapping.
+    int i = n - 1, j = m - 1;
+    while (i >= 0 && j >= 0 && backtrack[i][j]) {
+        switch (backtrack[i][j]) {
+        case 1:
+            i -= 1;
+            break;
+        case 2:
+            j -= 1;
+            break;
+        case 3:
+            aToB->set(i + startOffset, j + startOffset);
+            bToA->set(j + startOffset, i + startOffset);
+            i -= 1;
+            j -= 1;
+            break;
+        default:
+            ASSERT_NOT_REACHED();
+        }
+    }
+
+    for (int i = 0; i < n; ++i) {
+        delete [] diff[i];
+        delete [] backtrack[i];
+    }
+    delete [] diff;
+    delete [] backtrack;
+}
+
 } // namespace
 
 namespace blink {
 
 enum MediaListSource {
     MediaListSourceLinkedSheet,
     MediaListSourceInlineSheet,
     MediaListSourceMediaRule,
     MediaListSourceImportRule
 };
@@ skipping 22 matching lines @@
     : m_style(style)
     , m_sourceData(sourceData)
     , m_parentStyleSheet(parentStyleSheet)
 {
     ASSERT(m_style);
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorStyle::buildObjectForStyle()
 {
     RefPtr<TypeBuilder::CSS::CSSStyle> result = styleWithProperties();
-    if (m_parentStyleSheet && !m_parentStyleSheet->id().isEmpty())
-        result->setStyleSheetId(m_parentStyleSheet->id());
-
     if (m_sourceData) {
+        if (m_parentStyleSheet && !m_parentStyleSheet->id().isEmpty())
+            result->setStyleSheetId(m_parentStyleSheet->id());
         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();
@@ skipping 203 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();
+    mapSourceDataToCSSOM();
 }
 
 InspectorStyleSheet::~InspectorStyleSheet()
 {
 }
 
 DEFINE_TRACE(InspectorStyleSheet)
 {
     visitor->trace(m_cssAgent);
     visitor->trace(m_resourceAgent);
     visitor->trace(m_pageStyleSheet);
     visitor->trace(m_sourceData);
-    visitor->trace(m_flatRules);
+    visitor->trace(m_cssomFlatRules);
+    visitor->trace(m_parsedFlatRules);
     InspectorStyleSheetBase::trace(visitor);
 }
 
 static String styleSheetURL(CSSStyleSheet* pageStyleSheet)
 {
     if (pageStyleSheet && !pageStyleSheet->contents()->baseURL().isEmpty())
         return pageStyleSheet->contents()->baseURL().string();
     return emptyString();
 }
 
@@ skipping 19 matching lines @@
     {
         CSSStyleSheet::RuleMutationScope mutationScope(m_pageStyleSheet.get());
         m_pageStyleSheet->contents()->parseString(text);
     }
 
     if (listener())
         listener()->didReparseStyleSheet();
     onStyleSheetTextChanged();
     m_pageStyleSheet->ownerDocument()->styleResolverChanged(FullStyleUpdate);
 
-    collectFlatRules();
+    mapSourceDataToCSSOM();
     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;
     }
 
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = findRuleByHeaderRange(range);
     if (!sourceData || !sourceData->styleSourceData) {
         exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing source range");
         return nullptr;
     }
 
-    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(sourceData.get());
+    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(sourceData);
     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);
+    if (!replaceText(sourceData->ruleHeaderRange, text, newRange, oldText))
+        mapSourceDataToCSSOM();
     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;
     }
 
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = findRuleByBodyRange(range);
     if (!sourceData || !sourceData->styleSourceData) {
         exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing style source range");
         return nullptr;
     }
 
-    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(sourceData.get());
+    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(sourceData);
     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);
+    if (!replaceText(sourceData->ruleBodyRange, text, newRange, oldText))
+        mapSourceDataToCSSOM();
     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;
     }
 
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = findRuleByHeaderRange(range);
     if (!sourceData || !sourceData->mediaSourceData) {
         exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing source range");
         return nullptr;
     }
 
-    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(sourceData.get());
+    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(sourceData);
     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);
+    if (!replaceText(sourceData->ruleHeaderRange, text, newRange, oldText))
+        mapSourceDataToCSSOM();
+
     onStyleSheetTextChanged();
 
     return mediaRule;
 }
 
-RefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyleSheet::ruleAfterSourceRange(const SourceRange& sourceRange)
+RefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyleSheet::ruleSourceDataAfterSourceRange(const SourceRange& sourceRange)
 {
     ASSERT(m_sourceData);
     unsigned index = 0;
     for (; index < m_sourceData->size(); ++index) {
         RefPtrWillBeRawPtr<CSSRuleSourceData> sd = m_sourceData->at(index);
         if (sd->ruleHeaderRange.start >= sourceRange.end)
             break;
     }
     return index < m_sourceData->size() ? m_sourceData->at(index) : nullptr;
 }
@@ skipping 48 matching lines @@
         if (ruleSourceData->ruleHeaderRange.start < sourceRange.start && sourceRange.start < ruleSourceData->ruleBodyRange.start) {
             exceptionState.throwDOMException(NotFoundError, "Cannot insert rule inside rule selector.");
             return nullptr;
         }
         if (sourceRange.start < ruleSourceData->ruleBodyRange.start || ruleSourceData->ruleBodyRange.end < sourceRange.start)
             continue;
         if (!containingRuleSourceData || containingRuleSourceData->ruleBodyRange.length() > ruleSourceData->ruleBodyRange.length())
             containingRuleSourceData = ruleSourceData;
     }
 
-    RefPtrWillBeRawPtr<CSSRuleSourceData> insertBefore = ruleAfterSourceRange(sourceRange);
-    RefPtrWillBeRawPtr<CSSRule> insertBeforeRule = ruleForSourceData(insertBefore.get());
+    RefPtrWillBeRawPtr<CSSRuleSourceData> insertBefore = ruleSourceDataAfterSourceRange(sourceRange);
+    RefPtrWillBeRawPtr<CSSRule> insertBeforeRule = ruleForSourceData(insertBefore);
 
     if (!containingRuleSourceData)
         return insertCSSOMRuleInStyleSheet(insertBeforeRule.get(), ruleText, exceptionState);
 
-    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(containingRuleSourceData.get());
+    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(containingRuleSourceData);
     if (!rule || rule->type() != CSSRule::MEDIA_RULE) {
         exceptionState.throwDOMException(NotFoundError, "Cannot insert rule in non-media rule.");
         return nullptr;
     }
 
     return insertCSSOMRuleInMediaRule(toCSSMediaRule(rule.get()), insertBeforeRule.get(), 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;
     }
 
+    // Enforce renumber to get proper insertion anchor.
+    mapSourceDataToCSSOM();
+
     RefPtrWillBeRawPtr<CSSStyleRule> styleRule = insertCSSOMRuleBySourceRange(location, ruleText, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     replaceText(location, ruleText, addedRange, nullptr);
-    collectFlatRules();
+    mapSourceDataToCSSOM();
 
     onStyleSheetTextChanged();
     return styleRule;
 }
 
 bool InspectorStyleSheet::deleteRule(const SourceRange& range, ExceptionState& exceptionState)
 {
     if (!m_sourceData) {
         exceptionState.throwDOMException(NotFoundError, "Style is read-only.");
         return false;
     }
 
     // Find index of CSSRule that entirely belongs to the range.
     RefPtrWillBeRawPtr<CSSRuleSourceData> foundData = nullptr;
 
     for (size_t i = 0; i < m_sourceData->size(); ++i) {
         RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_sourceData->at(i);
         unsigned ruleStart = ruleSourceData->ruleHeaderRange.start;
         unsigned ruleEnd = ruleSourceData->ruleBodyRange.end + 1;
         bool startBelongs = ruleStart >= range.start && ruleStart < range.end;
         bool endBelongs = ruleEnd > range.start && ruleEnd <= range.end;
 
         if (startBelongs != endBelongs)
             break;
         if (!startBelongs)
             continue;
         if (!foundData || foundData->ruleBodyRange.length() > ruleSourceData->ruleBodyRange.length())
             foundData = ruleSourceData;
     }
-    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(foundData.get());
+    RefPtrWillBeRawPtr<CSSRule> rule = ruleForSourceData(foundData);
     if (!rule) {
         exceptionState.throwDOMException(NotFoundError, "No style rule could be found in given range.");
         return false;
     }
     CSSStyleSheet* styleSheet = rule->parentStyleSheet();
     if (!styleSheet) {
         exceptionState.throwDOMException(NotFoundError, "No parent stylesheet could be found.");
         return false;
     }
     CSSRule* parentRule = rule->parentRule();
@@ skipping 14 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);
-    collectFlatRules();
+    mapSourceDataToCSSOM();
 
     onStyleSheetTextChanged();
     return true;
 }
 
-void InspectorStyleSheet::replaceText(const SourceRange& range, const String& text, SourceRange* newRange, String* oldText)
+bool 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);
     if (newRange)
         *newRange = SourceRange(range.start, range.start + text.length());
-    innerSetText(sheetText, true);
+    return innerSetText(sheetText, true);
 }
 
-void InspectorStyleSheet::innerSetText(const String& text, bool markAsLocallyModified)
+bool InspectorStyleSheet::innerSetText(const String& text, bool markAsLocallyModified)
 {
+    unsigned sizeBefore = m_sourceData ? m_sourceData->size() : 0;
+
     OwnPtrWillBeRawPtr<RuleSourceDataList> ruleTree = adoptPtrWillBeNoop(new RuleSourceDataList());
+    RefPtrWillBeRawPtr<StyleSheetContents> styleSheet = StyleSheetContents::create(m_pageStyleSheet->contents()->parserContext());
     StyleSheetHandler handler(text, m_pageStyleSheet->ownerDocument(), ruleTree.get());
-    CSSParser::parseSheetForInspector(parserContextForDocument(m_pageStyleSheet->ownerDocument()), text, handler);
+    CSSParser::parseSheetForInspector(m_pageStyleSheet->contents()->parserContext(), styleSheet.get(), text, handler);
+    RefPtrWillBeRawPtr<CSSStyleSheet> sourceDataSheet;
+    if (toCSSImportRule(m_pageStyleSheet->ownerRule()))
+        sourceDataSheet = CSSStyleSheet::create(styleSheet, toCSSImportRule(m_pageStyleSheet->ownerRule()));
+    else
+        sourceDataSheet = CSSStyleSheet::create(styleSheet, m_pageStyleSheet->ownerNode());
+
+    m_parsedFlatRules.clear();
+    collectFlatRules(sourceDataSheet.get(), &m_parsedFlatRules);
+
     m_sourceData = adoptPtrWillBeNoop(new RuleSourceDataList());
     flattenSourceData(ruleTree.get(), m_sourceData.get());
     m_text = text;
 
     if (markAsLocallyModified) {
         Element* element = ownerStyleElement();
         if (element)
             m_cssAgent->addEditedStyleElement(DOMNodeIds::idForNode(element), text);
         else
             m_cssAgent->addEditedStyleSheet(finalURL(), text);
     }
+    return sizeBefore == m_sourceData->size();
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSStyleSheetHeader> InspectorStyleSheet::buildObjectForStyleSheetInfo()
 {
     CSSStyleSheet* styleSheet = pageStyleSheet();
     if (!styleSheet)
         return nullptr;
 
     Document* document = styleSheet->ownerDocument();
     LocalFrame* frame = document ? document->frame() : nullptr;
@@ skipping 227 matching lines @@
 
     for (size_t i = 0; i < m_sourceData->size(); ++i) {
         RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_sourceData->at(i);
         if (ruleSourceData->ruleBodyRange.start == sourceRange.start && ruleSourceData->ruleBodyRange.end == sourceRange.end) {
             return ruleSourceData;
         }
     }
     return nullptr;
 }
 
-RefPtrWillBeRawPtr<CSSRule> InspectorStyleSheet::ruleForSourceData(CSSRuleSourceData* sourceData)
+RefPtrWillBeRawPtr<CSSRule> InspectorStyleSheet::ruleForSourceData(RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData)
 {
     if (!m_sourceData || !sourceData)
         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;
+    size_t index = m_sourceData->find(sourceData.get());
+    if (index == kNotFound)
+        return nullptr;
+    IndexMap::iterator it = m_sourceDataToRule.find(index);
+    if (it == m_sourceDataToRule.end())
+        return nullptr;
+
+    ASSERT(it->value < m_cssomFlatRules.size());
+
+    // Check that CSSOM did not mutate this rule.
+    RefPtrWillBeRawPtr<CSSRule> result = m_cssomFlatRules.at(it->value);
+    if (m_parsedFlatRules.at(index)->cssText() != result->cssText())
+        return nullptr;
+    return result;
 }
 
-RefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyleSheet::sourceDataForRule(CSSRule* rule)
+RefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyleSheet::sourceDataForRule(RefPtrWillBeRawPtr<CSSRule> rule)
 {
     if (!m_sourceData || !rule)
         return nullptr;
+    size_t index = m_cssomFlatRules.find(rule.get());
+    if (index == kNotFound)
+        return nullptr;
+    IndexMap::iterator it = m_ruleToSourceData.find(index);
+    if (it == m_ruleToSourceData.end())
+        return nullptr;
 
-    size_t index = m_flatRules.find(rule);
-    return index < m_sourceData->size() ? m_sourceData->at(index) : nullptr;
+    ASSERT(it->value < m_sourceData->size());
+
+    // Check that CSSOM did not mutate this rule.
+    RefPtrWillBeRawPtr<CSSRule> parsedRule = m_parsedFlatRules.at(it->value);
+    if (rule->cssText() != parsedRule->cssText())
+        return nullptr;
+
+    return m_sourceData->at(it->value);
 }
 
-void InspectorStyleSheet::collectFlatRules()
+void InspectorStyleSheet::mapSourceDataToCSSOM()
 {
-    m_flatRules.clear();
-    ::collectFlatRules(m_pageStyleSheet.get(), &m_flatRules);
+    m_ruleToSourceData.clear();
+    m_sourceDataToRule.clear();
+
+    m_cssomFlatRules.clear();
+    CSSRuleVector& cssomRules = m_cssomFlatRules;
+    collectFlatRules(m_pageStyleSheet.get(), &cssomRules);
+
+    if (!m_sourceData)
+        return;
+
+    CSSRuleVector& parsedRules = m_parsedFlatRules;
+
+    Vector<String> cssomRulesText = Vector<String>();
+    Vector<String> parsedRulesText = Vector<String>();
+    for (size_t i = 0; i < cssomRules.size(); ++i)
+        cssomRulesText.append(cssomRules.at(i)->cssText());
+    for (size_t j = 0; j < parsedRules.size(); ++j)
+        parsedRulesText.append(parsedRules.at(j)->cssText());
+
+    diff(cssomRulesText, parsedRulesText, &m_ruleToSourceData, &m_sourceDataToRule);
 }
 
 const CSSRuleVector& InspectorStyleSheet::flatRules()
 {
-    return m_flatRules;
+    return m_cssomFlatRules;
 }
 
 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;
 
@@ skipping 99 matching lines @@
 }
 
 DEFINE_TRACE(InspectorStyleSheetForInlineStyle)
 {
     visitor->trace(m_element);
     visitor->trace(m_inspectorStyle);
     InspectorStyleSheetBase::trace(visitor);
 }
 
 } // namespace blink