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 412 matching lines @@
     if (propertyData.at(0).name != bogusPropertyName)
         return false;
 
     return true;
 }
 
 } // namespace
 
 class ParsedStyleSheet : public NoBaseWillBeGarbageCollectedFinalized<ParsedStyleSheet> {
 public:
-    static PassOwnPtrWillBeRawPtr<ParsedStyleSheet> create(CSSStyleSheet* pageStyleSheet)
+    static PassOwnPtrWillBeRawPtr<ParsedStyleSheet> create(Document* document)
     {
-        return adoptPtrWillBeNoop(new ParsedStyleSheet(pageStyleSheet));
+        return adoptPtrWillBeNoop(new ParsedStyleSheet(document));
     }
 
     const String& text() const { ASSERT(m_hasText); return m_text; }
     void setText(const String&);
     bool hasText() const { return m_hasText; }
     bool ensureSourceData();
     bool hasSourceData() const { return m_sourceData; }
     PassRefPtrWillBeRawPtr<blink::CSSRuleSourceData> ruleSourceDataAt(unsigned) const;
     unsigned ruleCount() { return m_sourceData->size(); }
 
     DECLARE_TRACE();
 
 private:
-    explicit ParsedStyleSheet(CSSStyleSheet* pageStyleSheet);
+    explicit ParsedStyleSheet(Document*);
 
     void flattenSourceData(RuleSourceDataList*);
     void setSourceData(PassOwnPtrWillBeRawPtr<RuleSourceDataList>);
 
     String m_text;
     bool m_hasText;
     OwnPtrWillBeMember<RuleSourceDataList> m_sourceData;
-    RefPtrWillBeMember<CSSStyleSheet> m_pageStyleSheet;
+    RefPtrWillBeMember<Document> m_document;
 };
 
-ParsedStyleSheet::ParsedStyleSheet(CSSStyleSheet* pageStyleSheet)
+ParsedStyleSheet::ParsedStyleSheet(Document* document)
     : m_hasText(false)
-    , m_pageStyleSheet(pageStyleSheet)
+    , m_document(document)
 {
 }
 
 void ParsedStyleSheet::setText(const String& text)
 {
     m_hasText = true;
     m_text = text;
     setSourceData(nullptr);
 }
 
@@ skipping 25 matching lines @@
 
 bool ParsedStyleSheet::ensureSourceData()
 {
     if (hasSourceData())
         return true;
 
     if (!hasText())
         return false;
 
     OwnPtrWillBeRawPtr<RuleSourceDataList> result = adoptPtrWillBeNoop(new RuleSourceDataList());
-    StyleSheetHandler handler(text(), m_pageStyleSheet->ownerDocument(), result.get());
-    CSSParser::parseSheetForInspector(parserContextForDocument(m_pageStyleSheet->ownerDocument()), text(), handler);
+    StyleSheetHandler handler(text(), m_document.get(), result.get());
+    CSSParser::parseSheetForInspector(parserContextForDocument(m_document.get()), text(), handler);
     setSourceData(result.release());
     return hasSourceData();
 }
 
 void ParsedStyleSheet::setSourceData(PassOwnPtrWillBeRawPtr<RuleSourceDataList> sourceData)
 {
     if (!sourceData) {
         m_sourceData.clear();
         return;
     }
     m_sourceData = adoptPtrWillBeNoop(new RuleSourceDataList());
 
     // FIXME: This is a temporary solution to retain the original flat sourceData structure
     // containing only style rules, even though BisonCSSParser now provides the full rule source data tree.
     // Normally, we should just assign m_sourceData = sourceData;
     flattenSourceData(sourceData.get());
 }
 
 PassRefPtrWillBeRawPtr<blink::CSSRuleSourceData> ParsedStyleSheet::ruleSourceDataAt(unsigned index) const
 {
     if (!hasSourceData() || index >= m_sourceData->size())
         return nullptr;
 
     return m_sourceData->at(index);
 }
 
 DEFINE_TRACE(ParsedStyleSheet)
 {
     visitor->trace(m_sourceData);
-    visitor->trace(m_pageStyleSheet);
+    visitor->trace(m_document);
 }
 
 namespace blink {
 
 enum MediaListSource {
     MediaListSourceLinkedSheet,
     MediaListSourceInlineSheet,
     MediaListSourceMediaRule,
     MediaListSourceImportRule
 };
@@ skipping 20 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;
+    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;
             if (m_style->isPropertyImplicit(individualProperty))
                 continue;
             String individualValue = m_style->getPropertyValue(individualProperty);
             if (individualValue == "initial")
                 continue;
             if (!builder.isEmpty())
                 builder.append(' ');
             builder.append(individualValue);
         }
 
         return builder.toString();
     }
     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));
-        }
-    }
-
-    return result.release();
+    RefPtrWillBeRawPtr<InspectorStyle> is = inspectorStyle(style);
+    return is->buildObjectForStyle();

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

inline "is"

 }
 
 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 18 matching lines @@
 }
 
 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)
     , m_origin(origin)
     , m_documentURL(documentURL)
 {
-    m_parsedStyleSheet = ParsedStyleSheet::create(m_pageStyleSheet.get());
+    m_parsedStyleSheet = ParsedStyleSheet::create(m_pageStyleSheet->ownerDocument());
 }
 
 InspectorStyleSheet::~InspectorStyleSheet()
 {
 }
 
 DEFINE_TRACE(InspectorStyleSheet)
 {
     visitor->trace(m_cssAgent);
     visitor->trace(m_resourceAgent);
@@ skipping 37 matching lines @@
 
     if (listener())
         listener()->didReparseStyleSheet();
     onStyleSheetTextChanged();
     m_pageStyleSheet->ownerDocument()->styleResolverChanged(FullStyleUpdate);
     return true;
 }
 
 RefPtrWillBeRawPtr<CSSStyleRule> InspectorStyleSheet::setRuleSelector(const SourceRange& range, const String& text, SourceRange* newRange, String* oldText, ExceptionState& exceptionState)
 {
-    if (!verifySelectorText(ownerDocument(), text)) {
+    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) {
         exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing source range");
         return nullptr;
     }
 
     RefPtrWillBeRawPtr<CSSStyleRule>  styleRule = InspectorCSSAgent::asCSSStyleRule(rule);
     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(ownerDocument(), text)) {
+    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) {
         exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing style source range");
         return nullptr;
     }
 
     RefPtrWillBeRawPtr<CSSStyleRule> styleRule = InspectorCSSAgent::asCSSStyleRule(rule);
     styleRule->style()->setCSSText(text, exceptionState);
 
     replaceText(sourceData->ruleBodyRange, text, newRange, oldText);
     onStyleSheetTextChanged();
 
     return styleRule;
 }
 
 RefPtrWillBeRawPtr<CSSMediaRule> InspectorStyleSheet::setMediaRuleText(const SourceRange& range, const String& text, SourceRange* newRange, String* oldText, ExceptionState& exceptionState)
 {
-    if (!verifyMediaText(ownerDocument(), text)) {
+    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) {
         exceptionState.throwDOMException(NotFoundError, "Source range didn't match existing source range");
         return nullptr;
     }
@@ skipping 77 matching lines @@
     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(ownerDocument(), ruleText)) {
+    if (!verifyRuleText(m_pageStyleSheet->ownerDocument(), ruleText)) {
         exceptionState.throwDOMException(SyntaxError, "Rule text is not valid.");
         return nullptr;
     }
 
     if (!ensureParsedDataReady()) {
         exceptionState.throwDOMException(NotFoundError, "Cannot parse style sheet.");
         return nullptr;
     }
     ensureFlatRules();
 
@@ skipping 83 matching lines @@
 void InspectorStyleSheet::innerSetText(const String& newText)
 {
     Element* element = ownerStyleElement();
     if (element)
         m_cssAgent->addEditedStyleElement(DOMNodeIds::idForNode(element), newText);
     else
         m_cssAgent->addEditedStyleSheet(finalURL(), newText);
     m_parsedStyleSheet->setText(newText);
 }
 
-CSSStyleRule* InspectorStyleSheet::ruleAt(unsigned ruleIndex) const
-{
-    ASSERT(!id().isEmpty());
-    ensureFlatRules();
-    return InspectorCSSAgent::asCSSStyleRule(ruleIndex >= m_flatRules.size() ? nullptr : m_flatRules.at(ruleIndex).get());
-}
-
-CSSMediaRule* InspectorStyleSheet::mediaRuleAt(unsigned ruleIndex) const
-{
-    ASSERT(!id().isEmpty());
-    ensureFlatRules();
-    return InspectorCSSAgent::asCSSMediaRule(ruleIndex >= m_flatRules.size() ? nullptr : m_flatRules.at(ruleIndex).get());
-}
-
 PassRefPtr<TypeBuilder::CSS::CSSStyleSheetHeader> InspectorStyleSheet::buildObjectForStyleSheetInfo() const
 {
     CSSStyleSheet* styleSheet = pageStyleSheet();
     if (!styleSheet)
         return nullptr;
 
     Document* document = styleSheet->ownerDocument();
     LocalFrame* frame = document ? document->frame() : nullptr;
 
     RefPtr<TypeBuilder::CSS::CSSStyleSheetHeader> result = TypeBuilder::CSS::CSSStyleSheetHeader::create()
@@ skipping 39 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 35 matching lines @@
 }
 
 bool InspectorStyleSheet::getText(String* result) const
 {
     if (!ensureText())
         return false;
     *result = m_parsedStyleSheet->text();
     return true;
 }
 
-CSSStyleDeclaration* InspectorStyleSheet::styleAt(unsigned ruleIndex) const
-{
-    CSSStyleRule* rule = ruleAt(ruleIndex);
-    if (!rule)
-        return nullptr;
-
-    return rule->style();
-}
-
 PassRefPtr<TypeBuilder::CSS::SourceRange> InspectorStyleSheet::ruleHeaderSourceRange(const CSSRule* rule)
 {
     if (!ensureParsedDataReady())
         return nullptr;
 
     ensureFlatRules();
     size_t index = m_flatRules.find(rule);
     // FIXME(lusnikov): m_flatRules are not always aligned with the m_parsedStyleSheet rule source
     // datas due to the CSSOM operations that add/remove rules without changing source.
     // This is a design issue. See crbug.com/178410
@@ skipping 13 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);
 
-unsigned InspectorStyleSheet::ruleCount()
-{
-    return m_parsedStyleSheet->ruleCount();
+    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);
 }
 
 String InspectorStyleSheet::sourceURL() const
 {
     if (!m_sourceURL.isNull())
         return m_sourceURL;
     if (m_origin != TypeBuilder::CSS::StyleSheetOrigin::Regular) {
         m_sourceURL = "";
         return m_sourceURL;
     }
@@ skipping 74 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);
+    for (size_t i = 0; i < m_parsedStyleSheet->ruleCount() && i < m_flatRules.size(); ++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);
+    for (size_t i = 0; i < m_parsedStyleSheet->ruleCount() && i < m_flatRules.size(); ++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 37 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);
 }
 
-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);
     return success;
 }
 
 bool InspectorStyleSheet::resourceStyleSheetText(String* result) const
 {
     if (m_origin == TypeBuilder::CSS::StyleSheetOrigin::Injected || m_origin == TypeBuilder::CSS::StyleSheetOrigin::User_agent)
         return false;
 
-    if (!ownerDocument())
+    if (!m_pageStyleSheet->ownerDocument())
         return false;
 
     KURL url(ParsedURLString, m_pageStyleSheet->href());
     if (m_cssAgent->getEditedStyleSheet(url, result))
         return true;
 
     bool base64Encoded;
-    bool success = m_resourceAgent->fetchResourceContent(ownerDocument(), url, result, &base64Encoded);
+    bool success = m_resourceAgent->fetchResourceContent(m_pageStyleSheet->ownerDocument(), url, result, &base64Encoded);
     return success && !base64Encoded;
 }
 
 Element* InspectorStyleSheet::ownerStyleElement() const
 {
     Node* ownerNode = m_pageStyleSheet->ownerNode();
     if (!ownerNode || !ownerNode->isElementNode())
         return nullptr;
     Element* ownerElement = toElement(ownerNode);
 
@@ skipping 14 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)) {
+    if (!verifyStyleText(&m_element->document(), 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
+PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyleSheetForInlineStyle::inspectorStyle(RefPtrWillBeRawPtr<CSSStyleDeclaration> style)
 {
-    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_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);
     }
-
-    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)
-{
-    ASSERT_UNUSED(ruleIndex, !ruleIndex);
     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