DevTools: remove InspectorCSSId, it serves no purpose.

Source/core/inspector/InspectorCSSAgent.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 199 matching lines @@
 
 private:
     RefPtrWillBeMember<InspectorStyleSheetBase> m_styleSheet;
     String m_text;
     String m_oldText;
 };
 
 class InspectorCSSAgent::SetPropertyTextAction final : public InspectorCSSAgent::StyleSheetAction {
     WTF_MAKE_NONCOPYABLE(SetPropertyTextAction);
 public:
-    SetPropertyTextAction(InspectorStyleSheetBase* styleSheet, const InspectorCSSId& cssId, unsigned propertyIndex, const String& text, bool overwrite)
+    SetPropertyTextAction(InspectorStyleSheetBase* styleSheet, unsigned ruleIndex, unsigned propertyIndex, const String& text, bool overwrite)
         : InspectorCSSAgent::StyleSheetAction("SetPropertyText")
         , m_styleSheet(styleSheet)
-        , m_cssId(cssId)
+        , m_ruleIndex(ruleIndex)
         , m_propertyIndex(propertyIndex)
         , m_text(text)
         , m_overwrite(overwrite)
     {
     }
 
     virtual String toString() override
     {
         return mergeId() + ": " + m_oldStyleText + " -> " + m_text;
     }
 
     virtual bool perform(ExceptionState& exceptionState) override
     {
         return redo(exceptionState);
     }
 
     virtual bool undo(ExceptionState& exceptionState) override
     {
         String placeholder;
-        return m_styleSheet->setStyleText(m_cssId, m_oldStyleText);
+        return m_styleSheet->setStyleText(m_ruleIndex, m_oldStyleText);
     }
 
     virtual bool redo(ExceptionState& exceptionState) override
     {
-        if (!m_styleSheet->getStyleText(m_cssId, &m_oldStyleText))
+        if (!m_styleSheet->getStyleText(m_ruleIndex, &m_oldStyleText))
             return false;
-        bool result = m_styleSheet->setPropertyText(m_cssId, m_propertyIndex, m_text, m_overwrite, exceptionState);
-        m_styleSheet->getStyleText(m_cssId, &m_newStyleText);
+        bool result = m_styleSheet->setPropertyText(m_ruleIndex, m_propertyIndex, m_text, m_overwrite, exceptionState);
+        m_styleSheet->getStyleText(m_ruleIndex, &m_newStyleText);
         return result;
     }
 
     virtual String mergeId() override
     {
         return String::format("SetPropertyText %s:%u:%s", m_styleSheet->id().utf8().data(), m_propertyIndex, m_overwrite ? "true" : "false");
     }
 
     virtual void merge(PassRefPtrWillBeRawPtr<Action> action) override
     {
@@ skipping 10 matching lines @@
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_styleSheet);
         InspectorCSSAgent::StyleSheetAction::trace(visitor);
     }
 
 private:
     RefPtrWillBeMember<InspectorStyleSheetBase> m_styleSheet;
-    InspectorCSSId m_cssId;
+    unsigned m_ruleIndex;
     unsigned m_propertyIndex;
     String m_text;
     String m_oldStyleText;
     String m_newStyleText;
     bool m_overwrite;
 };
 
 class InspectorCSSAgent::SetRuleSelectorAction final : public InspectorCSSAgent::StyleSheetAction {
     WTF_MAKE_NONCOPYABLE(SetRuleSelectorAction);
 public:
-    SetRuleSelectorAction(InspectorStyleSheet* styleSheet, const InspectorCSSId& cssId, const String& selector)
+    SetRuleSelectorAction(InspectorStyleSheet* styleSheet, unsigned ruleIndex, const String& selector)
         : InspectorCSSAgent::StyleSheetAction("SetRuleSelector")
         , m_styleSheet(styleSheet)
-        , m_cssId(cssId)
+        , m_ruleIndex(ruleIndex)
         , m_selector(selector)
     {
     }
 
     virtual bool perform(ExceptionState& exceptionState) override
     {
-        m_oldSelector = m_styleSheet->ruleSelector(m_cssId, exceptionState);
+        m_oldSelector = m_styleSheet->ruleSelector(m_ruleIndex, exceptionState);
         if (exceptionState.hadException())
             return false;
         return redo(exceptionState);
     }
 
     virtual bool undo(ExceptionState& exceptionState) override
     {
-        return m_styleSheet->setRuleSelector(m_cssId, m_oldSelector, exceptionState);
+        return m_styleSheet->setRuleSelector(m_ruleIndex, m_oldSelector, exceptionState);
     }
 
     virtual bool redo(ExceptionState& exceptionState) override
     {
-        return m_styleSheet->setRuleSelector(m_cssId, m_selector, exceptionState);
+        return m_styleSheet->setRuleSelector(m_ruleIndex, m_selector, exceptionState);
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_styleSheet);
         InspectorCSSAgent::StyleSheetAction::trace(visitor);
     }
 
 private:
     RefPtrWillBeMember<InspectorStyleSheet> m_styleSheet;
-    InspectorCSSId m_cssId;
+    unsigned m_ruleIndex;
     String m_selector;
     String m_oldSelector;
 };
 
 class InspectorCSSAgent::SetMediaTextAction final : public InspectorCSSAgent::StyleSheetAction {
     WTF_MAKE_NONCOPYABLE(SetMediaTextAction);
 public:
-    SetMediaTextAction(InspectorStyleSheet* styleSheet, const InspectorCSSId& cssId, const String& text)
+    SetMediaTextAction(InspectorStyleSheet* styleSheet, unsigned ruleIndex, const String& text)
         : InspectorCSSAgent::StyleSheetAction("SetMediaText")
         , m_styleSheet(styleSheet)
-        , m_cssId(cssId)
+        , m_ruleIndex(ruleIndex)
         , m_text(text)
     {
     }
 
     virtual bool perform(ExceptionState& exceptionState) override
     {
-        m_oldText = m_styleSheet->mediaRuleText(m_cssId, exceptionState);
+        m_oldText = m_styleSheet->mediaRuleText(m_ruleIndex, exceptionState);
         if (exceptionState.hadException())
             return false;
         return redo(exceptionState);
     }
 
     virtual bool undo(ExceptionState& exceptionState) override
     {
-        return m_styleSheet->setMediaRuleText(m_cssId, m_oldText, exceptionState);
+        return m_styleSheet->setMediaRuleText(m_ruleIndex, m_oldText, exceptionState);
     }
 
     virtual bool redo(ExceptionState& exceptionState) override
     {
-        return m_styleSheet->setMediaRuleText(m_cssId, m_text, exceptionState);
+        return m_styleSheet->setMediaRuleText(m_ruleIndex, m_text, exceptionState);
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_styleSheet);
         InspectorCSSAgent::StyleSheetAction::trace(visitor);
     }
 
 private:
     RefPtrWillBeMember<InspectorStyleSheet> m_styleSheet;
-    InspectorCSSId m_cssId;
+    unsigned m_ruleIndex;
     String m_text;
     String m_oldText;
 };
 
 class InspectorCSSAgent::AddRuleAction final : public InspectorCSSAgent::StyleSheetAction {
     WTF_MAKE_NONCOPYABLE(AddRuleAction);
 public:
     AddRuleAction(InspectorStyleSheet* styleSheet, const String& ruleText, const SourceRange& location)
         : InspectorCSSAgent::StyleSheetAction("AddRule")
         , m_styleSheet(styleSheet)
         , m_ruleText(ruleText)
         , m_location(location)
     {
     }
 
     virtual bool perform(ExceptionState& exceptionState) override
     {
         return redo(exceptionState);
     }
 
     virtual bool undo(ExceptionState& exceptionState) override
     {
-        return m_styleSheet->deleteRule(m_newId, m_oldText, exceptionState);
+        return m_styleSheet->deleteRule(m_newOrdinal, m_oldText, exceptionState);
     }
 
     virtual bool redo(ExceptionState& exceptionState) override
     {
         if (!m_styleSheet->getText(&m_oldText))
             return false;
         CSSStyleRule* cssStyleRule = m_styleSheet->addRule(m_ruleText, m_location, exceptionState);
         if (exceptionState.hadException())
             return false;
-        m_newId = m_styleSheet->ruleId(cssStyleRule);
+        m_newOrdinal = m_styleSheet->indexOf(cssStyleRule);
         return true;
     }
 
-    InspectorCSSId newRuleId() { return m_newId; }
+    unsigned newRuleOrdinal() { return m_newOrdinal; }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_styleSheet);
         InspectorCSSAgent::StyleSheetAction::trace(visitor);
     }
 
 private:
     RefPtrWillBeMember<InspectorStyleSheet> m_styleSheet;
-    InspectorCSSId m_newId;
+    unsigned m_newOrdinal;
     String m_ruleText;
     String m_oldText;
     SourceRange m_location;
 };
 
 // static
 CSSStyleRule* InspectorCSSAgent::asCSSStyleRule(CSSRule* rule)
 {
     if (!rule || rule->type() != CSSRule::STYLE_RULE)
         return nullptr;
@@ skipping 349 matching lines @@
         RefPtr<TypeBuilder::Array<TypeBuilder::CSS::InheritedStyleEntry> > entries = TypeBuilder::Array<TypeBuilder::CSS::InheritedStyleEntry>::create();
         Element* parentElement = element->parentElement();
         while (parentElement) {
             StyleResolver& parentStyleResolver = parentElement->ownerDocument()->ensureStyleResolver();
             RefPtrWillBeRawPtr<CSSRuleList> parentMatchedRules = parentStyleResolver.cssRulesForElement(parentElement, StyleResolver::AllCSSRules);
             RefPtr<TypeBuilder::CSS::InheritedStyleEntry> entry = TypeBuilder::CSS::InheritedStyleEntry::create()
                 .setMatchedCSSRules(buildArrayForMatchedRuleList(parentMatchedRules.get(), parentElement, NOPSEUDO));
             if (parentElement->style() && parentElement->style()->length()) {
                 InspectorStyleSheetForInlineStyle* styleSheet = asInspectorStyleSheet(parentElement);
                 if (styleSheet)
-                    entry->setInlineStyle(styleSheet->buildObjectForStyle(styleSheet->styleForId(InspectorCSSId(styleSheet->id(), 0))));
+                    entry->setInlineStyle(styleSheet->buildObjectForStyle(styleSheet->styleAt(0)));
             }
 
             entries->addItem(entry.release());
             parentElement = parentElement->parentElement();
         }
 
         inheritedEntries = entries.release();
     }
 }
 
@@ skipping 12 matching lines @@
     attributesStyle = attributes ? attributes.release() : nullptr;
 }
 
 void InspectorCSSAgent::getComputedStyleForNode(ErrorString* errorString, int nodeId, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSComputedStyleProperty> >& style)
 {
     Node* node = m_domAgent->assertNode(errorString, nodeId);
     if (!node)
         return;
 
     RefPtrWillBeRawPtr<CSSComputedStyleDeclaration> computedStyleInfo = CSSComputedStyleDeclaration::create(node, true);
-    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = InspectorStyle::create(InspectorCSSId(), computedStyleInfo, 0);
+    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = InspectorStyle::create(0, computedStyleInfo, 0);
     style = inspectorStyle->buildArrayForComputedStyle();
 }
 
 void InspectorCSSAgent::collectPlatformFontsForLayoutObject(LayoutText* layoutObject, HashCountedSet<String>* fontStats)
 {
     for (InlineTextBox* box = layoutObject->firstTextBox(); box; box = box->nextTextBox()) {
         const ComputedStyle& style = layoutObject->styleRef(box->isFirstLineStyle());
         const Font& font = style.font();
         TextRun run = box->constructTextRunForInspector(style, font);
         SimpleShaper shaper(&font, run);
@@ skipping 124 matching lines @@
 }
 
 void InspectorCSSAgent::setPropertyText(ErrorString* errorString, const String& styleSheetId, const RefPtr<JSONObject>& range, const String& text, RefPtr<TypeBuilder::CSS::CSSStyle>& result)
 {
     InspectorStyleSheetBase* inspectorStyleSheet = assertStyleSheetForId(errorString, styleSheetId);
     if (!inspectorStyleSheet)
         return;
     SourceRange propertyRange;
     if (!jsonRangeToSourceRange(errorString, inspectorStyleSheet, range, &propertyRange))
         return;
-    InspectorCSSId compoundId;
-    unsigned propertyIndex;
+    unsigned ruleIndex = 0;
+    unsigned propertyIndex = 0;
     bool overwrite;
-    if (!inspectorStyleSheet->findPropertyByRange(propertyRange, &compoundId, &propertyIndex, &overwrite)) {
+    if (!inspectorStyleSheet->findPropertyByRange(propertyRange, &ruleIndex, &propertyIndex, &overwrite)) {
         *errorString = "Source range didn't match any existing property source range nor any property insertion point";
         return;
     }
 
     TrackExceptionState exceptionState;
-    bool success = m_domAgent->history()->perform(adoptRefWillBeNoop(new SetPropertyTextAction(inspectorStyleSheet, compoundId, propertyIndex, text, overwrite)), exceptionState);
+    bool success = m_domAgent->history()->perform(adoptRefWillBeNoop(new SetPropertyTextAction(inspectorStyleSheet, ruleIndex, propertyIndex, text, overwrite)), exceptionState);
     if (success)
-        result = inspectorStyleSheet->buildObjectForStyle(inspectorStyleSheet->styleForId(compoundId));
+        result = inspectorStyleSheet->buildObjectForStyle(inspectorStyleSheet->styleAt(ruleIndex));
     *errorString = InspectorDOMAgent::toErrorString(exceptionState);
 }
 
 void InspectorCSSAgent::setRuleSelector(ErrorString* errorString, const String& styleSheetId, const RefPtr<JSONObject>& range, const String& selector, RefPtr<TypeBuilder::CSS::CSSRule>& result)
 {
     InspectorStyleSheet* inspectorStyleSheet = assertInspectorStyleSheetForId(errorString, styleSheetId);
     if (!inspectorStyleSheet) {
         *errorString = "Stylesheet not found";
         return;
     }
     SourceRange selectorRange;
     if (!jsonRangeToSourceRange(errorString, inspectorStyleSheet, range, &selectorRange))
         return;
-    InspectorCSSId compoundId;
-    if (!inspectorStyleSheet->findRuleBySelectorRange(selectorRange, &compoundId)) {
+    unsigned ruleIndex = 0;
+    if (!inspectorStyleSheet->findRuleBySelectorRange(selectorRange, &ruleIndex)) {
         *errorString = "Source range didn't match any rule selector source range";
         return;
     }
 
     TrackExceptionState exceptionState;
-    bool success = m_domAgent->history()->perform(adoptRefWillBeNoop(new SetRuleSelectorAction(inspectorStyleSheet, compoundId, selector)), exceptionState);
+    bool success = m_domAgent->history()->perform(adoptRefWillBeNoop(new SetRuleSelectorAction(inspectorStyleSheet, ruleIndex, selector)), exceptionState);
     if (success) {
-        CSSStyleRule* rule = inspectorStyleSheet->ruleForId(compoundId);
+        CSSStyleRule* rule = inspectorStyleSheet->ruleAt(ruleIndex);
         result = inspectorStyleSheet->buildObjectForRule(rule, buildMediaListChain(rule));
     }
     *errorString = InspectorDOMAgent::toErrorString(exceptionState);
 }
 
 void InspectorCSSAgent::setMediaText(ErrorString* errorString, const String& styleSheetId, const RefPtr<JSONObject>& range, const String& text, RefPtr<TypeBuilder::CSS::CSSMedia>& result)
 {
     InspectorStyleSheet* inspectorStyleSheet = assertInspectorStyleSheetForId(errorString, styleSheetId);
     if (!inspectorStyleSheet) {
         *errorString = "Stylesheet not found";
         return;
     }
     SourceRange textRange;
     if (!jsonRangeToSourceRange(errorString, inspectorStyleSheet, range, &textRange))
         return;
-    InspectorCSSId compoundId;
-    if (!inspectorStyleSheet->findMediaRuleByRange(textRange, &compoundId)) {
+    unsigned ruleIndex = 0;
+    if (!inspectorStyleSheet->findMediaRuleByRange(textRange, &ruleIndex)) {
         *errorString = "Source range didn't match any media rule source range";
         return;
     }
 
     TrackExceptionState exceptionState;
-    bool success = m_domAgent->history()->perform(adoptRefWillBeNoop(new SetMediaTextAction(inspectorStyleSheet, compoundId, text)), exceptionState);
+    bool success = m_domAgent->history()->perform(adoptRefWillBeNoop(new SetMediaTextAction(inspectorStyleSheet, ruleIndex, text)), exceptionState);
     if (success) {
-        CSSMediaRule* rule = inspectorStyleSheet->mediaRuleForId(compoundId);
+        CSSMediaRule* rule = inspectorStyleSheet->mediaRuleAt(ruleIndex);
         String sourceURL = rule->parentStyleSheet()->contents()->baseURL();
         if (sourceURL.isEmpty())
             sourceURL = InspectorDOMAgent::documentURLString(rule->parentStyleSheet()->ownerDocument());
         result = buildMediaObject(rule->media(), MediaListSourceMediaRule, sourceURL, rule->parentStyleSheet());
     }
     *errorString = InspectorDOMAgent::toErrorString(exceptionState);
 }
 
 void InspectorCSSAgent::createStyleSheet(ErrorString* errorString, const String& frameId, TypeBuilder::CSS::StyleSheetId* outStyleSheetId)
 {
@@ skipping 30 matching lines @@
         return;
 
     TrackExceptionState exceptionState;
     RefPtrWillBeRawPtr<AddRuleAction> action = adoptRefWillBeNoop(new AddRuleAction(inspectorStyleSheet, ruleText, ruleLocation));
     bool success = m_domAgent->history()->perform(action, exceptionState);
     if (!success) {
         *errorString = InspectorDOMAgent::toErrorString(exceptionState);
         return;
     }
 
-    InspectorCSSId ruleId = action->newRuleId();
-    CSSStyleRule* rule = inspectorStyleSheet->ruleForId(ruleId);
+    unsigned ruleOrdinal = action->newRuleOrdinal();
+    CSSStyleRule* rule = inspectorStyleSheet->ruleAt(ruleOrdinal);
     result = inspectorStyleSheet->buildObjectForRule(rule, buildMediaListChain(rule));
 }
 
 void InspectorCSSAgent::forcePseudoState(ErrorString* errorString, int nodeId, const RefPtr<JSONArray>& forcedPseudoClasses)
 {
     Element* element = m_domAgent->assertElement(errorString, nodeId);
     if (!element)
         return;
 
     unsigned forcedPseudoState = computePseudoClassMask(forcedPseudoClasses.get());
@@ skipping 412 matching lines @@
     if (!element->isStyledElement())
         return nullptr;
 
     // FIXME: Ugliness below.
     StylePropertySet* attributeStyle = const_cast<StylePropertySet*>(element->presentationAttributeStyle());
     if (!attributeStyle)
         return nullptr;
 
     MutableStylePropertySet* mutableAttributeStyle = toMutableStylePropertySet(attributeStyle);
 
-    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = InspectorStyle::create(InspectorCSSId(), mutableAttributeStyle->ensureCSSStyleDeclaration(), 0);
+    RefPtrWillBeRawPtr<InspectorStyle> inspectorStyle = InspectorStyle::create(0, mutableAttributeStyle->ensureCSSStyleDeclaration(), 0);
     return inspectorStyle->buildObjectForStyle();
 }
 
 void InspectorCSSAgent::didRemoveDocument(Document* document)
 {
     if (document)
         m_documentToViaInspectorStyleSheet.remove(document);
 }
 
 void InspectorCSSAgent::didRemoveDOMNode(Node* node)
@@ skipping 70 matching lines @@
     visitor->trace(m_invalidatedDocuments);
     visitor->trace(m_nodeToInspectorStyleSheet);
     visitor->trace(m_documentToViaInspectorStyleSheet);
 #endif
     visitor->trace(m_inspectorUserAgentStyleSheet);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink