DevTools: [CSS] cache lineEndings in 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 478 matching lines @@
 
 namespace blink {
 
 enum MediaListSource {
     MediaListSourceLinkedSheet,
     MediaListSourceInlineSheet,
     MediaListSourceMediaRule,
     MediaListSourceImportRule
 };
 
-static PassRefPtr<TypeBuilder::CSS::SourceRange> buildSourceRangeObject(const SourceRange& range, Vector<unsigned>* lineEndings)
+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())
@@ skipping 30 matching lines @@
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorStyle::buildObjectForStyle() const
 {
     RefPtr<TypeBuilder::CSS::CSSStyle> result = styleWithProperties();
     if (!m_styleId.isEmpty())
         result->setStyleSheetId(m_styleId.styleSheetId());
 
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = extractSourceData();
     if (sourceData)
-        result->setRange(buildSourceRangeObject(sourceData->ruleBodyRange, m_parentStyleSheet->lineEndings().get()));
+        result->setRange(buildSourceRangeObject(sourceData->ruleBodyRange, m_parentStyleSheet->lineEndings()));
 
     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;
     populateAllProperties(properties);
 
@@ skipping 126 matching lines @@
             continue;
         result.append(InspectorStyleProperty(CSSPropertySourceData(name, value, !m_style->getPropertyPriority(name).isEmpty(), false, true, SourceRange()), false));
     }
 }
 
 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;
-    OwnPtr<Vector<unsigned> > lineEndings(m_parentStyleSheet ? m_parentStyleSheet->lineEndings() : PassOwnPtr<Vector<unsigned> >());
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = extractSourceData();
 
     WillBeHeapVector<InspectorStyleProperty> properties;
     populateAllProperties(properties);
 
     for (WillBeHeapVector<InspectorStyleProperty>::iterator it = properties.begin(), itEnd = properties.end(); it != itEnd; ++it) {
         const CSSPropertySourceData& propertyEntry = it->sourceData;
         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 (it->hasRawText())
             property->setText(it->rawText);
 
         if (propertyEntry.important)
             property->setImportant(true);
         if (it->hasSource) {
-            property->setRange(buildSourceRangeObject(propertyEntry.range, lineEndings.get()));
+            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);
@@ skipping 120 matching lines @@
 
 void InspectorStyle::trace(Visitor* visitor)
 {
     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()))
 {
 }
 
 bool InspectorStyleSheetBase::setPropertyText(const InspectorCSSId& id, unsigned propertyIndex, const String& text, bool overwrite, ExceptionState& exceptionState)
 {
     RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = inspectorStyleForId(id);
     if (!inspectorStyle) {
         exceptionState.throwDOMException(NotFoundError, "No property could be found for the given ID.");
         return false;
     }
     return inspectorStyle->setPropertyText(propertyIndex, text, overwrite, exceptionState);
 }
 
 bool InspectorStyleSheetBase::getStyleText(const InspectorCSSId& id, String* text)
 {
     RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = inspectorStyleForId(id);
     if (!inspectorStyle)
         return false;
     return inspectorStyle->styleText(text);
 }
 
-void InspectorStyleSheetBase::fireStyleSheetChanged()
+void InspectorStyleSheetBase::onStyleSheetTextChanged()
 {
+    m_lineEndings = adoptPtrWillBeNoop(new LineEndings());
     if (listener())
         listener()->styleSheetChanged(this);
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorStyleSheetBase::buildObjectForStyle(CSSStyleDeclaration* style)
 {
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = nullptr;
     if (ensureParsedDataReady())
         sourceData = ruleSourceDataAt(styleId(style).ordinal());
 
@@ skipping 13 matching lines @@
         bool success = getText(&sheetText);
         if (success) {
             const SourceRange& bodyRange = sourceData->ruleBodyRange;
             result->setCssText(sheetText.substring(bodyRange.start, bodyRange.end - bodyRange.start));
         }
     }
 
     return result.release();
 }
 
-PassOwnPtr<Vector<unsigned> > InspectorStyleSheetBase::lineEndings()
+const LineEndings* InspectorStyleSheetBase::lineEndings()
 {
+    if (m_lineEndings->size() > 0)
+        return m_lineEndings.get();
     String text;
-    if (!getText(&text))
-        return PassOwnPtr<Vector<unsigned> >();
-    return WTF::lineEndings(text);
+    if (getText(&text))
+        m_lineEndings = WTF::lineEndings(text);
+    return m_lineEndings.get();
 }
 
 bool InspectorStyleSheetBase::lineNumberAndColumnToOffset(unsigned lineNumber, unsigned columnNumber, unsigned* offset)
 {
-    OwnPtr<Vector<unsigned> > endings = lineEndings();
+    const LineEndings* endings = lineEndings();
     if (lineNumber >= endings->size())
         return false;
     unsigned charactersInLine = lineNumber > 0 ? endings->at(lineNumber) - endings->at(lineNumber - 1) - 1 : endings->at(0);
     if (columnNumber > charactersInLine)
         return false;
     TextPosition position(OrdinalNumber::fromZeroBasedInt(lineNumber), OrdinalNumber::fromZeroBasedInt(columnNumber));
     *offset = position.toOffset(*endings).zeroBasedInt();
     return true;
 }
 
@@ skipping 91 matching lines @@
         m_pageStyleSheet->contents()->clearRules();
         m_pageStyleSheet->clearChildRuleCSSOMWrappers();
     }
     {
         CSSStyleSheet::RuleMutationScope mutationScope(m_pageStyleSheet.get());
         m_pageStyleSheet->contents()->parseString(text);
     }
 
     if (listener())
         listener()->didReparseStyleSheet();
-    fireStyleSheetChanged();
+    onStyleSheetTextChanged();
     m_pageStyleSheet->ownerDocument()->styleResolverChanged(FullStyleUpdate);
     return true;
 }
 
 String InspectorStyleSheet::ruleSelector(const InspectorCSSId& id, ExceptionState& exceptionState)
 {
     CSSStyleRule* rule = ruleForId(id);
     if (!rule) {
         exceptionState.throwDOMException(NotFoundError, "No rule was found for the given ID.");
         return "";
@@ skipping 17 matching lines @@
     rule->setSelectorText(selector);
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = ruleSourceDataAt(id.ordinal());
     if (!sourceData) {
         exceptionState.throwDOMException(NotFoundError, "The selector '" + selector + "' could not be set.");
         return false;
     }
 
     String sheetText = m_parsedStyleSheet->text();
     sheetText.replace(sourceData->ruleHeaderRange.start, sourceData->ruleHeaderRange.length(), selector);
     updateText(sheetText);
-    fireStyleSheetChanged();
+    onStyleSheetTextChanged();
     return true;
 }
 
 unsigned InspectorStyleSheet::ruleIndexBySourceRange(const CSSMediaRule* parentMediaRule, const SourceRange& sourceRange)
 {
     unsigned index = 0;
     for (size_t i = 0; i < m_flatRules.size(); ++i) {
         RefPtrWillBeRawPtr<CSSRule> rule = m_flatRules.at(i);
         if (rule->parentRule() != parentMediaRule)
             continue;
@@ skipping 115 matching lines @@
         return 0;
     }
 
     ensureFlatRules();
     CSSStyleRule* styleRule = insertCSSOMRuleBySourceRange(location, ruleText, exceptionState);
     if (exceptionState.hadException())
         return 0;
 
     text.insert(ruleText, location.start);
 
-    m_parsedStyleSheet->setText(text);
+    updateText(text);
     m_flatRules.clear();
 
-    fireStyleSheetChanged();
+    onStyleSheetTextChanged();
     return styleRule;
 }
 
 bool InspectorStyleSheet::deleteRule(const InspectorCSSId& id, const String& oldText, ExceptionState& exceptionState)
 {
     RefPtrWillBeRawPtr<CSSStyleRule> rule = ruleForId(id);
     if (!rule) {
         exceptionState.throwDOMException(NotFoundError, "No style rule could be found for the provided ID.");
         return false;
     }
@@ skipping 26 matching lines @@
         while (index < styleSheet->length() && styleSheet->item(index) != rule)
             ++index;
         ASSERT(index < styleSheet->length());
         styleSheet->deleteRule(index, exceptionState);
     }
     // |rule| MAY NOT be addressed after this line!
 
     if (exceptionState.hadException())
         return false;
 
-    m_parsedStyleSheet->setText(oldText);
+    updateText(oldText);
     m_flatRules.clear();
-    fireStyleSheetChanged();
+    onStyleSheetTextChanged();
     return true;
 }
 
 void InspectorStyleSheet::updateText(const String& newText)
 {
     Element* element = ownerStyleElement();
     if (!element)
         m_pageAgent->addEditedResourceContent(finalURL(), newText);
     m_parsedStyleSheet->setText(newText);
 }
 
-
 CSSStyleRule* InspectorStyleSheet::ruleForId(const InspectorCSSId& id) const
 {
     ASSERT(!id.isEmpty());
     ensureFlatRules();
     return InspectorCSSAgent::asCSSStyleRule(id.ordinal() >= m_flatRules.size() ? 0 : m_flatRules.at(id.ordinal()).get());
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSStyleSheetHeader> InspectorStyleSheet::buildObjectForStyleSheetInfo() const
 {
     CSSStyleSheet* styleSheet = pageStyleSheet();
@@ skipping 33 matching lines @@
         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().get()));
+        simpleSelector->setRange(buildSourceRangeObject(range, lineEndings()));
         result->addItem(simpleSelector.release());
     }
     return result.release();
 }
 
 PassRefPtr<TypeBuilder::CSS::SelectorList> InspectorStyleSheet::buildObjectForSelectorList(CSSStyleRule* rule)
 {
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = nullptr;
     if (ensureParsedDataReady())
         sourceData = ruleSourceDataAt(styleId(rule->style()).ordinal());
@@ skipping 68 matching lines @@
         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
     if (index == kNotFound || index >= m_parsedStyleSheet->ruleCount())
         return nullptr;
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = m_parsedStyleSheet->ruleSourceDataAt(static_cast<unsigned>(index));
-    return buildSourceRangeObject(sourceData->ruleHeaderRange, lineEndings().get());
+    return buildSourceRangeObject(sourceData->ruleHeaderRange, lineEndings());
 }
 
 PassRefPtr<TypeBuilder::CSS::SourceRange> InspectorStyleSheet::mediaQueryExpValueSourceRange(const CSSRule* rule, size_t mediaQueryIndex, size_t mediaQueryExpIndex)
 {
     if (!ensureParsedDataReady())
         return nullptr;
     ensureFlatRules();
     size_t index = m_flatRules.find(rule);
     if (index == kNotFound || index >= m_parsedStyleSheet->ruleCount())
         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().get());
+    return buildSourceRangeObject(mediaQueryData->expData.at(mediaQueryExpIndex).valueRange, lineEndings());
 }
 
 PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyleSheet::inspectorStyleForId(const InspectorCSSId& id)
 {
     CSSStyleDeclaration* style = styleForId(id);
     if (!style)
         return nullptr;
 
     return InspectorStyle::create(id, style, this);
 }
@@ skipping 197 matching lines @@
 
     String patchedStyleSheetText;
     bool success = styleSheetTextWithChangedStyle(style, text, &patchedStyleSheetText);
     if (!success)
         return false;
 
     TrackExceptionState exceptionState;
     style->setCSSText(text, exceptionState);
     if (!exceptionState.hadException()) {
         updateText(patchedStyleSheetText);
-        fireStyleSheetChanged();
+        onStyleSheetTextChanged();
     }
 
     return !exceptionState.hadException();
 }
 
 bool InspectorStyleSheet::styleSheetTextWithChangedStyle(CSSStyleDeclaration* style, const String& newStyleText, String* result)
 {
     if (!style)
         return false;
     if (!ensureParsedDataReady())
@@ skipping 85 matching lines @@
     if (m_element->isStyledElement() && m_element->style() != m_inspectorStyle->cssStyle())
         m_inspectorStyle = InspectorStyle::create(InspectorCSSId(id(), 0), inlineStyle(), this);
     m_ruleSourceData.clear();
 }
 
 bool InspectorStyleSheetForInlineStyle::setText(const String& text, ExceptionState& exceptionState)
 {
     bool success = setStyleText(InspectorCSSId(id(), 0), text);
     if (!success)
         exceptionState.throwDOMException(SyntaxError, "Style sheet text is invalid.");
-    else
-        fireStyleSheetChanged();
     return success;
 }
 
 bool InspectorStyleSheetForInlineStyle::getText(String* result) const
 {
     if (!m_isStyleTextValid) {
         m_styleText = elementStyleText();
         m_isStyleTextValid = true;
     }
     *result = m_styleText;
     return true;
 }
 
 bool InspectorStyleSheetForInlineStyle::setStyleText(const InspectorCSSId& id, const String& text)
 {
     CSSStyleDeclaration* style = styleForId(id);
     if (!style)
         return false;
     ASSERT_UNUSED(style, style == inlineStyle());
     TrackExceptionState exceptionState;
 
     {
         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();
-        fireStyleSheetChanged();
+        onStyleSheetTextChanged();
     }
     return !exceptionState.hadException();
 }
 
 Document* InspectorStyleSheetForInlineStyle::ownerDocument() const
 {
     return &m_element->document();
 }
 
 bool InspectorStyleSheetForInlineStyle::ensureParsedDataReady()
@@ skipping 58 matching lines @@
 void InspectorStyleSheetForInlineStyle::trace(Visitor* visitor)
 {
     visitor->trace(m_element);
     visitor->trace(m_ruleSourceData);
     visitor->trace(m_inspectorStyle);
     InspectorStyleSheetBase::trace(visitor);
 }
 
 } // namespace blink