DevTools: remove parsedstylesheet struct, inline it into inspectorstylesheet.

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 408 matching lines @@
     if (propertyCount != 1)
         return false;
 
     // Check for the property name.
     if (propertyData.at(0).name != bogusPropertyName)
         return false;
 
     return true;
 }
 
-} // namespace
-
-class ParsedStyleSheet : public NoBaseWillBeGarbageCollectedFinalized<ParsedStyleSheet> {
-public:
-    static PassOwnPtrWillBeRawPtr<ParsedStyleSheet> create(Document* document)
-    {
-        return adoptPtrWillBeNoop(new ParsedStyleSheet(document));
-    }
-
-    const String& text() { ASSERT(m_hasText); return m_text; }
-    void setText(const String&);
-    bool hasText() { return m_hasText; }
-    bool ensureSourceData();
-    bool hasSourceData() { return m_sourceData; }
-    PassRefPtrWillBeRawPtr<blink::CSSRuleSourceData> ruleSourceDataAt(unsigned);
-    unsigned ruleCount() { return m_sourceData->size(); }
-
-    DECLARE_TRACE();
-
-private:
-    explicit ParsedStyleSheet(Document*);
-
-    void flattenSourceData(RuleSourceDataList*);
-    void setSourceData(PassOwnPtrWillBeRawPtr<RuleSourceDataList>);
-
-    String m_text;
-    bool m_hasText;
-    OwnPtrWillBeMember<RuleSourceDataList> m_sourceData;
-    RefPtrWillBeMember<Document> m_document;
-};
-
-ParsedStyleSheet::ParsedStyleSheet(Document* document)
-    : m_hasText(false)
-    , m_document(document)
-{
-}
-
-void ParsedStyleSheet::setText(const String& text)
-{
-    m_hasText = true;
-    m_text = text;
-    setSourceData(nullptr);
-}
-
-void ParsedStyleSheet::flattenSourceData(RuleSourceDataList* dataList)
+void flattenSourceData(RuleSourceDataList* dataList, RuleSourceDataList* result)
 {
     for (size_t i = 0; i < dataList->size(); ++i) {
         RefPtrWillBeMember<CSSRuleSourceData>& data = dataList->at(i);
 
-        // The m_sourceData->append()'ed types should be exactly the same as in collectFlatRules().
+        // The result->append()'ed types should be exactly the same as in collectFlatRules().
         switch (data->type) {
         case StyleRule::Style:
         case StyleRule::Import:
         case StyleRule::Page:
         case StyleRule::FontFace:
         case StyleRule::Viewport:
         case StyleRule::Keyframes:
-            m_sourceData->append(data);
+            result->append(data);
             break;
         case StyleRule::Media:
         case StyleRule::Supports:
-            m_sourceData->append(data);
-            flattenSourceData(&data->childRules);
+            result->append(data);
+            flattenSourceData(&data->childRules, result);
             break;
         default:
             break;
         }
     }
 }
 
-bool ParsedStyleSheet::ensureSourceData()
-{
-    if (hasSourceData())
-        return true;
-
-    if (!hasText())
-        return false;
-
-    OwnPtrWillBeRawPtr<RuleSourceDataList> result = adoptPtrWillBeNoop(new RuleSourceDataList());
-    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)
-{
-    if (!hasSourceData() || index >= m_sourceData->size())
-        return nullptr;
-
-    return m_sourceData->at(index);
-}
-
-DEFINE_TRACE(ParsedStyleSheet)
-{
-    visitor->trace(m_sourceData);
-    visitor->trace(m_document);
-}
+} // namespace
 
 namespace blink {
 
 enum MediaListSource {
     MediaListSourceLinkedSheet,
     MediaListSourceInlineSheet,
     MediaListSourceMediaRule,
     MediaListSourceImportRule
 };
 
@@ skipping 257 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->ownerDocument());
+    String text;
+    bool success = inlineStyleSheetText(&text);
+    if (!success)
+        success = resourceStyleSheetText(&text);
+    if (success)
+        innerSetText(text, false);
 }
 
 InspectorStyleSheet::~InspectorStyleSheet()
 {
 }
 
 DEFINE_TRACE(InspectorStyleSheet)
 {
     visitor->trace(m_cssAgent);
     visitor->trace(m_resourceAgent);
     visitor->trace(m_pageStyleSheet);
-    visitor->trace(m_parsedStyleSheet);
+    visitor->trace(m_sourceData);
     visitor->trace(m_flatRules);
     InspectorStyleSheetBase::trace(visitor);
 }
 
 static String styleSheetURL(CSSStyleSheet* pageStyleSheet)
 {
     if (pageStyleSheet && !pageStyleSheet->contents()->baseURL().isEmpty())
         return pageStyleSheet->contents()->baseURL().string();
     return emptyString();
 }
 
 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);
+    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();
@@ skipping 74 matching lines @@
     mediaRule->media()->setMediaText(text);
 
     replaceText(sourceData->ruleHeaderRange, text, newRange, oldText);
     onStyleSheetTextChanged();
 
     return mediaRule;
 }
 
 unsigned InspectorStyleSheet::ruleIndexBySourceRange(const CSSMediaRule* parentMediaRule, const SourceRange& sourceRange)
 {
+    ASSERT(m_sourceData);
     unsigned index = 0;
-    for (size_t i = 0; i < m_flatRules.size(); ++i) {
+    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_parsedStyleSheet->ruleSourceDataAt(i);
+        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_sourceData->at(i);
         if (ruleSourceData->ruleBodyRange.end < sourceRange.start)
             ++index;
     }
     return index;
 }
 
 CSSStyleRule* InspectorStyleSheet::insertCSSOMRuleInStyleSheet(const SourceRange& sourceRange, const String& ruleText, ExceptionState& exceptionState)
 {
     unsigned index = ruleIndexBySourceRange(nullptr, sourceRange);
     m_pageStyleSheet->insertRule(ruleText, index, exceptionState);
@@ skipping 16 matching lines @@
     if (!styleRule) {
         mediaRule->deleteRule(index, ASSERT_NO_EXCEPTION);
         exceptionState.throwDOMException(SyntaxError, "The rule '" + ruleText + "' could not be added in media rule.");
         return nullptr;
     }
     return styleRule;
 }
 
 CSSStyleRule* InspectorStyleSheet::insertCSSOMRuleBySourceRange(const SourceRange& sourceRange, const String& ruleText, ExceptionState& exceptionState)
 {
+    ASSERT(m_sourceData);
+
     int containingRuleIndex = -1;
     unsigned containingRuleLength = 0;
-    for (size_t i = 0; i < m_parsedStyleSheet->ruleCount(); ++i) {
-        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_parsedStyleSheet->ruleSourceDataAt(i);
+    for (size_t i = 0; i < m_sourceData->size(); ++i) {
+        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_sourceData->at(i);
         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 (containingRuleIndex == -1 || containingRuleLength > ruleSourceData->ruleBodyRange.length()) {
             containingRuleIndex = i;
             containingRuleLength = ruleSourceData->ruleBodyRange.length();
         }
@@ skipping 14 matching lines @@
     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 (!ensureParsedDataReady()) {
-        exceptionState.throwDOMException(NotFoundError, "Cannot parse style sheet.");
+    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();
 
     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<CSSRule> rule = nullptr;
     unsigned containingRuleLength = 0;
 
-    for (size_t i = 0; i < m_flatRules.size() && i < m_parsedStyleSheet->ruleCount(); ++i) {
-        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_parsedStyleSheet->ruleSourceDataAt(i);
+    for (size_t i = 0; i < m_flatRules.size() && 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 (!rule || containingRuleLength > ruleSourceData->ruleBodyRange.length()) {
             containingRuleLength = ruleSourceData->ruleBodyRange.length();
             rule = m_flatRules.at(i).get();
         }
     }
     if (!rule) {
         exceptionState.throwDOMException(NotFoundError, "No style rule could be found in given range.");
         return false;
     }
     CSSStyleSheet* styleSheet = rule->parentStyleSheet();
-    if (!styleSheet || !ensureParsedDataReady()) {
+    if (!styleSheet) {
         exceptionState.throwDOMException(NotFoundError, "No parent stylesheet could be found.");
         return false;
     }
     CSSRule* parentRule = rule->parentRule();
     if (parentRule) {
         if (parentRule->type() != CSSRule::MEDIA_RULE) {
             exceptionState.throwDOMException(NotFoundError, "Cannot remove rule from non-media rule.");
             return false;
         }
         CSSMediaRule* parentMediaRule = toCSSMediaRule(parentRule);
@@ skipping 15 matching lines @@
         return false;
 
     replaceText(range, "", nullptr, nullptr);
     m_flatRules.clear();
     onStyleSheetTextChanged();
     return true;
 }
 
 void InspectorStyleSheet::replaceText(const SourceRange& range, const String& text, SourceRange* newRange, String* oldText)
 {
-    String sheetText = m_parsedStyleSheet->text();
+    String sheetText = m_text;

[lushnikov, 2015/06/23 17:58:44]

you can avoid this cloning

     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);
+    innerSetText(sheetText, true);
 }
 
-void InspectorStyleSheet::innerSetText(const String& newText)
+void InspectorStyleSheet::innerSetText(const String& text, bool markAsLocallyModified)
 {
-    Element* element = ownerStyleElement();
-    if (element)
-        m_cssAgent->addEditedStyleElement(DOMNodeIds::idForNode(element), newText);
-    else
-        m_cssAgent->addEditedStyleSheet(finalURL(), newText);
-    m_parsedStyleSheet->setText(newText);
+    OwnPtrWillBeRawPtr<RuleSourceDataList> ruleTree = adoptPtrWillBeNoop(new RuleSourceDataList());
+    StyleSheetHandler handler(text, m_pageStyleSheet->ownerDocument(), ruleTree.get());
+    CSSParser::parseSheetForInspector(parserContextForDocument(m_pageStyleSheet->ownerDocument()), text, handler);
+    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);
+    }
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSStyleSheetHeader> InspectorStyleSheet::buildObjectForStyleSheetInfo()
 {
     CSSStyleSheet* styleSheet = pageStyleSheet();
     if (!styleSheet)
         return nullptr;
 
     Document* document = styleSheet->ownerDocument();
     LocalFrame* frame = document ? document->frame() : nullptr;
@@ skipping 41 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 = m_parsedStyleSheet->ruleSourceDataAt(ruleIndex);
-    }
+    if (ruleIndex != UINT_MAX && m_sourceData && ruleIndex < m_sourceData->size())
+        sourceData = m_sourceData->at(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());
+        selectors = selectorsFromSource(sourceData.get(), m_text);
     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();
@@ skipping 22 matching lines @@
     }
 
     if (mediaStack)
         result->setMedia(mediaStack);
 
     return result.release();
 }
 
 bool InspectorStyleSheet::getText(String* result)
 {
-    if (!ensureText())
-        return false;
-    *result = m_parsedStyleSheet->text();
-    return true;
+    if (m_sourceData) {
+        *result = m_text;
+        return true;
+    }
+    return false;
 }
 
 PassRefPtr<TypeBuilder::CSS::SourceRange> InspectorStyleSheet::ruleHeaderSourceRange(const CSSRule* rule)
 {
-    if (!ensureParsedDataReady())
+    if (!m_sourceData)
         return nullptr;
 
     ensureFlatRules();
     size_t index = m_flatRules.find(rule);
-    // FIXME(lusnikov): m_flatRules are not always aligned with the m_parsedStyleSheet rule source
+    // 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_parsedStyleSheet->ruleCount())
+    if (index == kNotFound || index >= m_sourceData->size())
         return nullptr;
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = m_parsedStyleSheet->ruleSourceDataAt(static_cast<unsigned>(index));
+    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)
 {
-    if (!ensureParsedDataReady())
+    if (!m_sourceData)
         return nullptr;
     ensureFlatRules();
     size_t index = m_flatRules.find(rule);
-    if (index == kNotFound || index >= m_parsedStyleSheet->ruleCount())
+    if (index == kNotFound || index >= m_sourceData->size())
         return nullptr;
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = m_parsedStyleSheet->ruleSourceDataAt(static_cast<unsigned>(index));
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = m_sourceData->at(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::inspectorStyle(RefPtrWillBeRawPtr<CSSStyleDeclaration> style)
 {
     if (!style)
         return nullptr;
 
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = nullptr;
     unsigned ruleIndex = indexOf(style.get());
-    if (ruleIndex != UINT_MAX && ensureParsedDataReady())
-        sourceData = m_parsedStyleSheet->ruleSourceDataAt(ruleIndex);
+    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);
 }
 
@@ skipping 78 matching lines @@
     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;
     }
     return UINT_MAX;
 }
 
 bool InspectorStyleSheet::findRuleByHeaderRange(const SourceRange& sourceRange, CSSRule** pRule, CSSRuleSourceData** pSourceData)
 {
-    if (!ensureParsedDataReady())
+    if (!m_sourceData)
         return false;
     ensureFlatRules();
 
-    for (size_t i = 0; i < m_parsedStyleSheet->ruleCount() && i < m_flatRules.size(); ++i) {
-        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_parsedStyleSheet->ruleSourceDataAt(i);
+    for (size_t i = 0; i < m_sourceData->size() && i < m_flatRules.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;
         }
     }
     return false;
 }
 
 bool InspectorStyleSheet::findRuleByBodyRange(const SourceRange& sourceRange, CSSRule** pRule, CSSRuleSourceData** pSourceData)
 {
-    if (!ensureParsedDataReady())
+    if (!m_sourceData)
         return false;
     ensureFlatRules();
 
-    for (size_t i = 0; i < m_parsedStyleSheet->ruleCount() && i < m_flatRules.size(); ++i) {
-        RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = m_parsedStyleSheet->ruleSourceDataAt(i);
+    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;
 }
 
 const CSSRuleVector& InspectorStyleSheet::flatRules()
 {
     ensureFlatRules();
     return m_flatRules;
 }
 
-bool InspectorStyleSheet::ensureParsedDataReady()
-{
-    return ensureText() && m_parsedStyleSheet->ensureSourceData();
-}
-
-bool InspectorStyleSheet::ensureText()
-{
-    if (m_parsedStyleSheet->hasText())
-        return true;
-
-    String text;
-    bool success = originalStyleSheetText(&text);
-    if (success)
-        m_parsedStyleSheet->setText(text);
-    // No need to clear m_flatRules here - it's empty.
-
-    return success;
-}
-
 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 ParsedStyleSheet::flattenSourceData().
+        // 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::originalStyleSheetText(String* result)
-{
-    bool success = inlineStyleSheetText(result);
-    if (!success)
-        success = resourceStyleSheetText(result);
-    return success;
-}
-
 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