Make CSSRuleSourceData use the CSSRule Type enum

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 67 matching lines @@
         , m_commentParser(parserContextForDocument(document))
         , m_propertyRangeStart(UINT_MAX)
         , m_selectorRangeStart(UINT_MAX)
         , m_commentRangeStart(UINT_MAX)
         , m_mediaQueryExpValueRangeStart(UINT_MAX)
     {
         ASSERT(m_result);
     }
 
 private:
-    virtual void startRuleHeader(CSSRuleSourceData::Type, unsigned) override;
+    virtual void startRuleHeader(StyleRule::Type, unsigned) override;
     virtual void endRuleHeader(unsigned) override;
     virtual void startSelector(unsigned) override;
     virtual void endSelector(unsigned) override;
     virtual void startRuleBody(unsigned) override;
     virtual void endRuleBody(unsigned, bool) override;
     virtual void startProperty(unsigned) override;
     virtual void endProperty(bool, bool, unsigned, CSSParserError) override;
     virtual void startComment(unsigned) override;
     virtual void endComment(unsigned) override;
     virtual void startMediaQueryExp(unsigned offset) override;
@@ skipping 13 matching lines @@
     RuleSourceDataList m_currentRuleDataStack;
     RefPtrWillBeMember<CSSRuleSourceData> m_currentRuleData;
     CSSParser m_commentParser;
     unsigned m_propertyRangeStart;
     unsigned m_selectorRangeStart;
     unsigned m_commentRangeStart;
     RefPtrWillBeMember<CSSMediaQuerySourceData> m_currentMediaQueryData;
     unsigned m_mediaQueryExpValueRangeStart;
 };
 
-void StyleSheetHandler::startRuleHeader(CSSRuleSourceData::Type type, unsigned offset)
+void StyleSheetHandler::startRuleHeader(StyleRule::Type type, unsigned offset)
 {
     // Pop off data for a previous invalid rule.
     if (m_currentRuleData)
         m_currentRuleDataStack.removeLast();
 
     RefPtrWillBeRawPtr<CSSRuleSourceData> data = CSSRuleSourceData::create(type);
     data->ruleHeaderRange.start = offset;
     m_currentRuleData = data;
     m_currentRuleDataStack.append(data.release());
 }
@@ skipping 291 matching lines @@
     setSourceData(nullptr);
 }
 
 void ParsedStyleSheet::flattenSourceData(RuleSourceDataList* dataList)
 {
     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().
         switch (data->type) {
-        case CSSRuleSourceData::STYLE_RULE:
-        case CSSRuleSourceData::IMPORT_RULE:
-        case CSSRuleSourceData::CHARSET_RULE:
-        case CSSRuleSourceData::PAGE_RULE:
-        case CSSRuleSourceData::FONT_FACE_RULE:
-        case CSSRuleSourceData::VIEWPORT_RULE:
-        case CSSRuleSourceData::KEYFRAMES_RULE:
+        case StyleRule::Style:
+        case StyleRule::Import:
+        case StyleRule::Page:
+        case StyleRule::FontFace:
+        case StyleRule::Viewport:
+        case StyleRule::Keyframes:
             m_sourceData->append(data);
             break;
-        case CSSRuleSourceData::MEDIA_RULE:
-        case CSSRuleSourceData::SUPPORTS_RULE:
+        case StyleRule::Media:
+        case StyleRule::Supports:
             m_sourceData->append(data);
             flattenSourceData(&data->childRules);
             break;
+        case StyleRule::Unknown:
         default:
             break;
         }
     }
 }
 
 bool ParsedStyleSheet::ensureSourceData()
 {
     if (hasSourceData())
         return true;
@@ skipping 771 matching lines @@
 {
     DEFINE_STATIC_LOCAL(String, bogusPropertyName, ("-webkit-boguz-propertee"));
     RuleSourceDataList sourceData;
     RefPtrWillBeRawPtr<StyleSheetContents> styleSheetContents = StyleSheetContents::create(strictCSSParserContext());
     String text = selectorText + " { " + bogusPropertyName + ": none; }";
     StyleSheetHandler handler(text, ownerDocument(), styleSheetContents.get(), &sourceData);
     CSSParser::parseSheet(parserContextForDocument(ownerDocument()), styleSheetContents.get(), text, TextPosition::minimumPosition(), &handler);
 
     // Exactly one rule should be parsed.
     unsigned ruleCount = sourceData.size();
-    if (ruleCount != 1 || sourceData.at(0)->type != CSSRuleSourceData::STYLE_RULE)
+    if (ruleCount != 1 || sourceData.at(0)->type != StyleRule::Style)
         return false;
 
     // Exactly one property should be in style rule.
     WillBeHeapVector<CSSPropertySourceData>& propertyData = sourceData.at(0)->styleSourceData->propertyData;
     unsigned propertyCount = propertyData.size();
     if (propertyCount != 1)
         return false;
 
     // Check for the property name.
     if (propertyData.at(0).name != bogusPropertyName)
         return false;
 
     return true;
 }
 
 bool InspectorStyleSheet::verifyMediaText(const String& mediaText)
 {
     DEFINE_STATIC_LOCAL(String, bogusPropertyName, ("-webkit-boguz-propertee"));
     RuleSourceDataList sourceData;
     RefPtrWillBeRawPtr<StyleSheetContents> styleSheetContents = StyleSheetContents::create(strictCSSParserContext());
     String text = "@media " + mediaText + " { div { " + bogusPropertyName + ": none; } }";
     StyleSheetHandler handler(text, ownerDocument(), styleSheetContents.get(), &sourceData);
     CSSParser::parseSheet(parserContextForDocument(ownerDocument()), styleSheetContents.get(), text, TextPosition::minimumPosition(), &handler);
 
     // Exactly one media rule should be parsed.
     unsigned ruleCount = sourceData.size();
-    if (ruleCount != 1 || sourceData.at(0)->type != CSSRuleSourceData::MEDIA_RULE)
+    if (ruleCount != 1 || sourceData.at(0)->type != StyleRule::Media)
         return false;
 
     // Media rule should have exactly one style rule child.
     RuleSourceDataList& childSourceData = sourceData.at(0)->childRules;
     ruleCount = childSourceData.size();
     if (ruleCount != 1 || !childSourceData.at(0)->styleSourceData)
         return false;
 
     // Exactly one property should be in style rule.
     WillBeHeapVector<CSSPropertySourceData>& propertyData = childSourceData.at(0)->styleSourceData->propertyData;
@@ skipping 661 matching lines @@
         m_isStyleTextValid = true;
     }
 
     if (m_ruleSourceData)
         return true;
 
     m_ruleSourceData = getStyleAttributeData();
 
     bool success = !!m_ruleSourceData;
     if (!success) {
-        m_ruleSourceData = CSSRuleSourceData::create(CSSRuleSourceData::STYLE_RULE);
+        m_ruleSourceData = CSSRuleSourceData::create(StyleRule::Style);
         return false;
     }
 
     return true;
 }
 
 PassRefPtrWillBeRawPtr<InspectorStyle> InspectorStyleSheetForInlineStyle::inspectorStyleForId(const InspectorCSSId& id)
 {
     ASSERT_UNUSED(id, !id.ordinal());
     return m_inspectorStyle;
 }
 
 CSSStyleDeclaration* InspectorStyleSheetForInlineStyle::inlineStyle() const
 {
     return m_element->style();
 }
 
 const String& InspectorStyleSheetForInlineStyle::elementStyleText() const
 {
     return m_element->getAttribute("style").string();
 }
 
 PassRefPtrWillBeRawPtr<CSSRuleSourceData> InspectorStyleSheetForInlineStyle::getStyleAttributeData() const
 {
     if (!m_element->isStyledElement())
         return nullptr;
 
     if (m_styleText.isEmpty()) {
-        RefPtrWillBeRawPtr<CSSRuleSourceData> result = CSSRuleSourceData::create(CSSRuleSourceData::STYLE_RULE);
+        RefPtrWillBeRawPtr<CSSRuleSourceData> result = CSSRuleSourceData::create(StyleRule::Style);
         result->ruleBodyRange.start = 0;
         result->ruleBodyRange.end = 0;
         return result.release();
     }
 
     RefPtrWillBeRawPtr<MutableStylePropertySet> tempDeclaration = MutableStylePropertySet::create();
     RuleSourceDataList ruleSourceDataResult;
     StyleSheetHandler handler(m_styleText, &m_element->document(), m_element->document().elementSheet().contents(), &ruleSourceDataResult);
     CSSParser(parserContextForDocument(&m_element->document())).parseDeclaration(tempDeclaration.get(), m_styleText, &handler, m_element->document().elementSheet().contents());
     return ruleSourceDataResult.first().release();
 }
 
 DEFINE_TRACE(InspectorStyleSheetForInlineStyle)
 {
     visitor->trace(m_element);
     visitor->trace(m_ruleSourceData);
     visitor->trace(m_inspectorStyle);
     InspectorStyleSheetBase::trace(visitor);
 }
 
 } // namespace blink