DevTools: remove InspectorCSSId, it serves no purpose.

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 454 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(const InspectorCSSId& styleId, PassRefPtrWillBeRawPtr<CSSStyleDeclaration> style, InspectorStyleSheetBase* parentStyleSheet)
+PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyle::create(unsigned ruleIndex, PassRefPtrWillBeRawPtr<CSSStyleDeclaration> style, InspectorStyleSheetBase* parentStyleSheet)
 {
-    return adoptRefWillBeNoop(new InspectorStyle(styleId, style, parentStyleSheet));
+    return adoptRefWillBeNoop(new InspectorStyle(ruleIndex, style, parentStyleSheet));
 }
 
-InspectorStyle::InspectorStyle(const InspectorCSSId& styleId, PassRefPtrWillBeRawPtr<CSSStyleDeclaration> style, InspectorStyleSheetBase* parentStyleSheet)
-    : m_styleId(styleId)
+InspectorStyle::InspectorStyle(unsigned ruleIndex, PassRefPtrWillBeRawPtr<CSSStyleDeclaration> style, InspectorStyleSheetBase* parentStyleSheet)
+    : m_ruleIndex(ruleIndex)
     , m_style(style)
     , m_parentStyleSheet(parentStyleSheet)
     , m_formatAcquired(false)
 {
     ASSERT(m_style);
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorStyle::buildObjectForStyle() const
 {
     RefPtr<TypeBuilder::CSS::CSSStyle> result = styleWithProperties();
-    if (!m_styleId.isEmpty())
-        result->setStyleSheetId(m_styleId.styleSheetId());
+    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()));
 
     return result.release();
 }
 
 PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSComputedStyleProperty> > InspectorStyle::buildArrayForComputedStyle() const
 {
@@ skipping 70 matching lines @@
     if (overwrite) {
         if (index >= allProperties.size()) {
             exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is greater than or equal to the maximum bound (" + String::number(allProperties.size()) + ").");
             return false;
         }
         editor.replaceProperty(index, propertyText);
     } else {
         editor.insertProperty(index, propertyText);
     }
 
-    return m_parentStyleSheet->setStyleText(m_styleId, editor.styleText());
+    return m_parentStyleSheet->setStyleText(m_ruleIndex, editor.styleText());
 }
 
 bool InspectorStyle::styleText(String* result) const
 {
     RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = extractSourceData();
     if (!sourceData)
         return false;
 
     return textForRange(sourceData->ruleBodyRange, result);
 }
@@ skipping 95 matching lines @@
     RefPtr<TypeBuilder::CSS::CSSStyle> result = TypeBuilder::CSS::CSSStyle::create()
         .setCssProperties(propertiesObject)
         .setShorthandEntries(shorthandEntries);
     return result.release();
 }
 
 PassRefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyle::extractSourceData() const
 {
     if (!m_parentStyleSheet || !m_parentStyleSheet->ensureParsedDataReady())
         return nullptr;
-    return m_parentStyleSheet->ruleSourceDataAt(m_styleId.ordinal());
+    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);
@@ skipping 90 matching lines @@
     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)
+bool InspectorStyleSheetBase::setPropertyText(unsigned ruleIndex, unsigned propertyIndex, const String& text, bool overwrite, ExceptionState& exceptionState)
 {
-    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = inspectorStyleForId(id);
+    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = inspectorStyleAt(ruleIndex);
     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)
+bool InspectorStyleSheetBase::getStyleText(unsigned ruleIndex, String* text)
 {
-    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = inspectorStyleForId(id);
+    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = inspectorStyleAt(ruleIndex);
     if (!inspectorStyle)
         return false;
     return inspectorStyle->styleText(text);
 }
 
 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;
     if (ensureParsedDataReady())
-        sourceData = ruleSourceDataAt(styleId(style).ordinal());
+        sourceData = ruleSourceDataAt(indexOf(style));
 
-    InspectorCSSId id = styleId(style);
-    if (id.isEmpty()) {
+    unsigned ruleIndex = indexOf(style);
+    if (id().isEmpty()) {
         // Any rule coming from User Agent and not from DefaultStyleSheet will not have id.
         // See InspectorCSSAgent::buildObjectForRule for details.
-        RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = InspectorStyle::create(id, style, this);
+        RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = InspectorStyle::create(ruleIndex, style, this);
         return inspectorStyle->buildObjectForStyle();
     }
-    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = inspectorStyleForId(id);
+    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));
         }
@@ skipping 18 matching lines @@
     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;
 }
 
-bool InspectorStyleSheetBase::findPropertyByRange(const SourceRange& sourceRange, InspectorCSSId* ruleId, unsigned* propertyIndex, bool* overwrite)
+bool InspectorStyleSheetBase::findPropertyByRange(const SourceRange& sourceRange, unsigned* ruleIndex, unsigned* propertyIndex, bool* overwrite)
 {
     if (!ensureParsedDataReady())
         return false;
     for (size_t i = 0; i < ruleCount(); ++i) {
         RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = ruleSourceDataAt(i);
         RefPtrWillBeRawPtr<CSSStyleSourceData> styleSourceData = ruleSourceData->styleSourceData;
         if (!styleSourceData)
             continue;
         if (ruleSourceData->ruleBodyRange.end < sourceRange.start || sourceRange.end < ruleSourceData->ruleBodyRange.start)
             continue;
         WillBeHeapVector<CSSPropertySourceData>& propertyData = styleSourceData->propertyData;
         for (size_t j = 0; j < propertyData.size(); ++j) {
             CSSPropertySourceData& property = propertyData.at(j);
             unsigned styleStart = ruleSourceData->ruleBodyRange.start;
             if (sourceRange.length() && property.range.start == sourceRange.start && property.range.end == sourceRange.end) {
-                *ruleId = InspectorCSSId(id(), i);
+                *ruleIndex = i;
                 *propertyIndex = j;
                 *overwrite = true;
                 return true;
             }
             if (!sourceRange.length() && styleStart <= sourceRange.start && sourceRange.start <= property.range.start) {
-                *ruleId = InspectorCSSId(id(), i);
+                *ruleIndex = i;
                 *propertyIndex = j;
                 *overwrite = false;
                 return true;
             }
         }
         if (!sourceRange.length() && ruleSourceData->ruleBodyRange.start <= sourceRange.start && sourceRange.start <= ruleSourceData->ruleBodyRange.end) {
-            *ruleId = InspectorCSSId(id(), i);
+            *ruleIndex = i;
             *propertyIndex = propertyData.size();
             *overwrite = false;
             return true;
         }
     }
     return false;
 }
 
 PassRefPtrWillBeRawPtr<InspectorStyleSheet> InspectorStyleSheet::create(InspectorResourceAgent* resourceAgent, const String& id, PassRefPtrWillBeRawPtr<CSSStyleSheet> pageStyleSheet, TypeBuilder::CSS::StyleSheetOrigin::Enum origin, const String& documentURL, InspectorCSSAgent* cssAgent)
 {
@@ skipping 56 matching lines @@
         m_pageStyleSheet->contents()->parseString(text);
     }
 
     if (listener())
         listener()->didReparseStyleSheet();
     onStyleSheetTextChanged();
     m_pageStyleSheet->ownerDocument()->styleResolverChanged(FullStyleUpdate);
     return true;
 }
 
-String InspectorStyleSheet::ruleSelector(const InspectorCSSId& id, ExceptionState& exceptionState)
+String InspectorStyleSheet::ruleSelector(unsigned ruleIndex, ExceptionState& exceptionState)
 {
-    CSSStyleRule* rule = ruleForId(id);
+    CSSStyleRule* rule = ruleAt(ruleIndex);
     if (!rule) {
         exceptionState.throwDOMException(NotFoundError, "No rule was found for the given ID.");
         return "";
     }
     return rule->selectorText();
 }
 
-bool InspectorStyleSheet::setRuleSelector(const InspectorCSSId& id, const String& selector, ExceptionState& exceptionState)
+bool InspectorStyleSheet::setRuleSelector(unsigned ruleIndex, const String& selector, ExceptionState& exceptionState)
 {
-    CSSStyleRule* rule = ruleForId(id);
+    CSSStyleRule* rule = ruleAt(ruleIndex);
     if (!rule) {
         exceptionState.throwDOMException(NotFoundError, "No rule was found for the given ID.");
         return false;
     }
     CSSStyleSheet* styleSheet = rule->parentStyleSheet();
     if (!styleSheet || !ensureParsedDataReady()) {
         exceptionState.throwDOMException(NotFoundError, "No stylesheet could be found in which to set the selector.");
         return false;
     }
 
     if (!verifySelectorText(selector)) {
         exceptionState.throwDOMException(SyntaxError, "Selector text is not valid.");
         return false;
     }
 
     rule->setSelectorText(selector);
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = ruleSourceDataAt(id.ordinal());
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = ruleSourceDataAt(ruleIndex);
     ASSERT(sourceData);
 
     String sheetText = m_parsedStyleSheet->text();
     sheetText.replace(sourceData->ruleHeaderRange.start, sourceData->ruleHeaderRange.length(), selector);
     updateText(sheetText);
     onStyleSheetTextChanged();
     return true;
 }
 
-String InspectorStyleSheet::mediaRuleText(const InspectorCSSId& id, ExceptionState& exceptionState)
+String InspectorStyleSheet::mediaRuleText(unsigned ruleIndex, ExceptionState& exceptionState)
 {
-    CSSMediaRule* rule = mediaRuleForId(id);
+    CSSMediaRule* rule = mediaRuleAt(ruleIndex);
     if (!rule) {
         exceptionState.throwDOMException(NotFoundError, "No media rule was found for the given ID.");
         return "";
     }
     return rule->media()->mediaText();
 }
 
-bool InspectorStyleSheet::setMediaRuleText(const InspectorCSSId& id, const String& text, ExceptionState& exceptionState)
+bool InspectorStyleSheet::setMediaRuleText(unsigned ruleIndex, const String& text, ExceptionState& exceptionState)
 {
-    CSSMediaRule* rule = mediaRuleForId(id);
+    CSSMediaRule* rule = mediaRuleAt(ruleIndex);
     if (!rule) {
         exceptionState.throwDOMException(NotFoundError, "No media rule was found for the given ID.");
         return false;
     }
     CSSStyleSheet* styleSheet = rule->parentStyleSheet();
     if (!styleSheet || !ensureParsedDataReady()) {
         exceptionState.throwDOMException(NotFoundError, "No stylesheet could be found in which to set the media text.");
         return false;
     }
     if (!verifyMediaText(text)) {
         exceptionState.throwDOMException(SyntaxError, "Media text is not valid.");
         return false;
     }
 
     rule->media()->setMediaText(text);
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = ruleSourceDataAt(id.ordinal());
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = ruleSourceDataAt(ruleIndex);
     ASSERT(sourceData && sourceData->mediaSourceData);
 
     String sheetText = m_parsedStyleSheet->text();
     sheetText.replace(sourceData->ruleHeaderRange.start, sourceData->ruleHeaderRange.length(), text);
     updateText(sheetText);
     onStyleSheetTextChanged();
     return true;
 }
 
 unsigned InspectorStyleSheet::ruleIndexBySourceRange(const CSSMediaRule* parentMediaRule, const SourceRange& sourceRange)
@@ skipping 185 matching lines @@
 
     text.insert(ruleText, location.start);
 
     updateText(text);
     m_flatRules.clear();
 
     onStyleSheetTextChanged();
     return styleRule;
 }
 
-bool InspectorStyleSheet::deleteRule(const InspectorCSSId& id, const String& oldText, ExceptionState& exceptionState)
+bool InspectorStyleSheet::deleteRule(unsigned ruleIndex, const String& oldText, ExceptionState& exceptionState)
 {
-    RefPtrWillBeRawPtr<CSSStyleRule> rule = ruleForId(id);
+    RefPtrWillBeRawPtr<CSSStyleRule> rule = ruleAt(ruleIndex);
     if (!rule) {
         exceptionState.throwDOMException(NotFoundError, "No style rule could be found for the provided ID.");
         return false;
     }
     CSSStyleSheet* styleSheet = rule->parentStyleSheet();
     if (!styleSheet || !ensureParsedDataReady()) {
         exceptionState.throwDOMException(NotFoundError, "No parent stylesheet could be found.");
         return false;
     }
 
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = ruleSourceDataAt(id.ordinal());
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = ruleSourceDataAt(ruleIndex);
     if (!sourceData) {
         exceptionState.throwDOMException(NotFoundError, "No style rule could be found for the provided ID.");
         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;
@@ skipping 25 matching lines @@
 void InspectorStyleSheet::updateText(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::ruleForId(const InspectorCSSId& id) const
+CSSStyleRule* InspectorStyleSheet::ruleAt(unsigned ruleIndex) const
 {
-    ASSERT(!id.isEmpty());
     ensureFlatRules();
-    return InspectorCSSAgent::asCSSStyleRule(id.ordinal() >= m_flatRules.size() ? nullptr : m_flatRules.at(id.ordinal()).get());
+    return InspectorCSSAgent::asCSSStyleRule(ruleIndex >= m_flatRules.size() ? nullptr : m_flatRules.at(ruleIndex).get());
 }
 
-CSSMediaRule* InspectorStyleSheet::mediaRuleForId(const InspectorCSSId& id) const
+CSSMediaRule* InspectorStyleSheet::mediaRuleAt(unsigned ruleIndex) const
 {
-    ASSERT(!id.isEmpty());
+    ASSERT(!id().isEmpty());
     ensureFlatRules();
-    return InspectorCSSAgent::asCSSMediaRule(id.ordinal() >= m_flatRules.size() ? nullptr : m_flatRules.at(id.ordinal()).get());
+    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;
@@ 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;
     if (ensureParsedDataReady())
-        sourceData = ruleSourceDataAt(styleId(rule->style()).ordinal());
+        sourceData = ruleSourceDataAt(indexOf(rule->style()));
     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 17 matching lines @@
     CSSStyleSheet* styleSheet = pageStyleSheet();
     if (!styleSheet)
         return nullptr;
 
     RefPtr<TypeBuilder::CSS::CSSRule> result = TypeBuilder::CSS::CSSRule::create()
         .setSelectorList(buildObjectForSelectorList(rule))
         .setOrigin(m_origin)
         .setStyle(buildObjectForStyle(rule->style()));
 
     if (canBind(m_origin)) {
-        InspectorCSSId id(ruleId(rule));
-        if (!id.isEmpty())
-            result->setStyleSheetId(id.styleSheetId());
+        if (!id().isEmpty())
+            result->setStyleSheetId(id());
     }
 
     if (mediaStack)
         result->setMedia(mediaStack);
 
     return result.release();
 }
 
 bool InspectorStyleSheet::getText(String* result) const
 {
     if (!ensureText())
         return false;
     *result = m_parsedStyleSheet->text();
     return true;
 }
 
-CSSStyleDeclaration* InspectorStyleSheet::styleForId(const InspectorCSSId& id) const
+CSSStyleDeclaration* InspectorStyleSheet::styleAt(unsigned ruleIndex) const
 {
-    CSSStyleRule* rule = ruleForId(id);
+    CSSStyleRule* rule = ruleAt(ruleIndex);
     if (!rule)
         return nullptr;
 
     return rule->style();
 }
 
 PassRefPtr<TypeBuilder::CSS::SourceRange> InspectorStyleSheet::ruleHeaderSourceRange(const CSSRule* rule)
 {
     if (!ensureParsedDataReady())
         return nullptr;
@@ skipping 19 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::inspectorStyleForId(const InspectorCSSId& id)
+PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyleSheet::inspectorStyleAt(unsigned ruleIndex)
 {
-    CSSStyleDeclaration* style = styleForId(id);
+    CSSStyleDeclaration* style = styleAt(ruleIndex);
     if (!style)
         return nullptr;
 
-    return InspectorStyle::create(id, style, this);
+    return InspectorStyle::create(ruleIndex, style, this);
 }
 
 unsigned InspectorStyleSheet::ruleCount()
 {
     return m_parsedStyleSheet->ruleCount();
 }
 
 String InspectorStyleSheet::sourceURL() const
 {
     if (!m_sourceURL.isNull())
@@ skipping 62 matching lines @@
         bool deprecated;
         String commentValue = ContentSearchUtils::findSourceMapURL(styleSheetText, ContentSearchUtils::CSSMagicComment, &deprecated);
         if (!commentValue.isEmpty()) {
             // FIXME: add deprecated console message here.
             return commentValue;
         }
     }
     return m_pageStyleSheet->contents()->sourceMapURL();
 }
 
-InspectorCSSId InspectorStyleSheet::styleId(CSSStyleDeclaration* style) const
+unsigned InspectorStyleSheet::indexOf(CSSStyleDeclaration* style) const
 {
-    unsigned index = ruleIndexByStyle(style);
-    if (index != UINT_MAX)
-        return InspectorCSSId(id(), index);
-    return InspectorCSSId();
+    ensureFlatRules();
+    for (unsigned i = 0, size = m_flatRules.size(); i < size; ++i) {
+        CSSStyleRule* styleRule = InspectorCSSAgent::asCSSStyleRule(m_flatRules.at(i).get());
+        if (styleRule && styleRule->style() == style)
+            return i;
+    }
+    return 0;
 }
 
-bool InspectorStyleSheet::findRuleBySelectorRange(const SourceRange& sourceRange, InspectorCSSId* ruleId)
+bool InspectorStyleSheet::findRuleBySelectorRange(const SourceRange& sourceRange, unsigned* ruleIndex)
 {
     if (!ensureParsedDataReady())
         return false;
     for (size_t i = 0; i < ruleCount(); ++i) {
         RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = ruleSourceDataAt(i);
         if (!ruleSourceData->styleSourceData)
             continue;
         if (ruleSourceData->ruleHeaderRange.start == sourceRange.start && ruleSourceData->ruleHeaderRange.end == sourceRange.end) {
-            *ruleId = InspectorCSSId(id(), i);
+            *ruleIndex = i;
             return true;
         }
     }
     return false;
 }
 
-bool InspectorStyleSheet::findMediaRuleByRange(const SourceRange& sourceRange, InspectorCSSId* ruleId)
+bool InspectorStyleSheet::findMediaRuleByRange(const SourceRange& sourceRange, unsigned* ruleIndex)
 {
     if (!ensureParsedDataReady())
         return false;
     for (size_t i = 0; i < ruleCount(); ++i) {
         RefPtrWillBeRawPtr<CSSRuleSourceData> ruleSourceData = ruleSourceDataAt(i);
         if (!ruleSourceData->mediaSourceData)
             continue;
         if (ruleSourceData->ruleHeaderRange.start == sourceRange.start && ruleSourceData->ruleHeaderRange.end == sourceRange.end) {
-            *ruleId = InspectorCSSId(id(), i);
+            *ruleIndex = i;
             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);
 }
 
-unsigned InspectorStyleSheet::ruleIndexByStyle(CSSStyleDeclaration* pageStyle) const
-{
-    ensureFlatRules();
-    for (unsigned i = 0, size = m_flatRules.size(); i < size; ++i) {
-        CSSStyleRule* styleRule = InspectorCSSAgent::asCSSStyleRule(m_flatRules.at(i).get());
-        if (styleRule && styleRule->style() == pageStyle)
-            return i;
-    }
-    return UINT_MAX;
-}
-
 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);
 }
 
-bool InspectorStyleSheet::setStyleText(const InspectorCSSId& id, const String& text)
+bool InspectorStyleSheet::setStyleText(unsigned ruleIndex, const String& text)
 {
-    CSSStyleDeclaration* style = styleForId(id);
+    CSSStyleDeclaration* style = styleAt(ruleIndex);
     if (!style)
         return false;
 
     if (!ensureParsedDataReady())
         return false;
 
     String patchedStyleSheetText;
     bool success = styleSheetTextWithChangedStyle(style, text, &patchedStyleSheetText);
     if (!success)
         return false;
 
     TrackExceptionState exceptionState;
     style->setCSSText(text, exceptionState);
     if (!exceptionState.hadException()) {
         updateText(patchedStyleSheetText);
         onStyleSheetTextChanged();
     }
 
     return !exceptionState.hadException();
 }
 
 bool InspectorStyleSheet::styleSheetTextWithChangedStyle(CSSStyleDeclaration* style, const String& newStyleText, String* result)
 {
     if (!style)
         return false;
     if (!ensureParsedDataReady())
         return false;
 
-    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = ruleSourceDataAt(styleId(style).ordinal());
+    RefPtrWillBeRawPtr<CSSRuleSourceData> sourceData = ruleSourceDataAt(indexOf(style));
     unsigned bodyStart = sourceData->ruleBodyRange.start;
     unsigned bodyEnd = sourceData->ruleBodyRange.end;
     ASSERT(bodyStart <= bodyEnd);
 
     String text = m_parsedStyleSheet->text();
     ASSERT_WITH_SECURITY_IMPLICATION(bodyEnd <= text.length()); // bodyEnd is exclusive
 
     text.replace(bodyStart, bodyEnd - bodyStart, newStyleText);
     *result = text;
     return true;
 }
 
-InspectorCSSId InspectorStyleSheet::ruleId(CSSStyleRule* rule) const
+unsigned InspectorStyleSheet::indexOf(CSSStyleRule* rule) const
 {
-    return styleId(rule->style());
+    return indexOf(rule->style());
 }
 
 bool InspectorStyleSheet::originalStyleSheetText(String* result) const
 {
     bool success = inlineStyleSheetText(result);
     if (!success)
         success = resourceStyleSheetText(result);
     return success;
 }
 
@@ skipping 42 matching lines @@
     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(InspectorCSSId(id, 0), inlineStyle(), this);
+    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(InspectorCSSId(id(), 0), inlineStyle(), this);
+        m_inspectorStyle = InspectorStyle::create(0, inlineStyle(), this);
     m_ruleSourceData.clear();
 }
 
 bool InspectorStyleSheetForInlineStyle::setText(const String& text, ExceptionState& exceptionState)
 {
-    bool success = setStyleText(InspectorCSSId(id(), 0), text);
+    bool success = setStyleText(0, text);
     if (!success)
         exceptionState.throwDOMException(SyntaxError, "Style sheet text is invalid.");
     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)
+bool InspectorStyleSheetForInlineStyle::setStyleText(unsigned ruleIndex, const String& text)
 {
-    CSSStyleDeclaration* style = styleForId(id);
+    CSSStyleDeclaration* style = styleAt(ruleIndex);
     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()) {
@@ skipping 27 matching lines @@
 
     bool success = !!m_ruleSourceData;
     if (!success) {
         m_ruleSourceData = CSSRuleSourceData::create(StyleRule::Style);
         return false;
     }
 
     return true;
 }
 
-PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyleSheetForInlineStyle::inspectorStyleForId(const InspectorCSSId& id)
+PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyleSheetForInlineStyle::inspectorStyleAt(unsigned ruleIndex)
 {
-    ASSERT_UNUSED(id, !id.ordinal());
+    ASSERT_UNUSED(!ruleIndex, !ruleIndex);

[kozy, 2015/06/15 09:49:28]

ASSERT_UNUSED(ruleIndex, !ruleIndex)

     return m_inspectorStyle;
 }
 
 CSSStyleDeclaration* InspectorStyleSheetForInlineStyle::inlineStyle() const
 {
     return m_element->style();
 }
 
 const String& InspectorStyleSheetForInlineStyle::elementStyleText() const
 {
@@ skipping 20 matching lines @@
 
 DEFINE_TRACE(InspectorStyleSheetForInlineStyle)
 {
     visitor->trace(m_element);
     visitor->trace(m_ruleSourceData);
     visitor->trace(m_inspectorStyle);
     InspectorStyleSheetBase::trace(visitor);
 }
 
 } // namespace blink