Changeset 112087 in webkit


Ignore:
Timestamp:
Mar 26, 2012 7:04:50 AM (12 years ago)
Author:
apavlov@chromium.org
Message:

Web Inspector: Migrate InspectorCSSAgent to strict protocol types
​https://bugs.webkit.org/show_bug.cgi?id=81923

Reviewed by Pavel Feldman.

No new tests, as this is a refactoring.

  • inspector/CodeGeneratorInspector.py:
  • inspector/InspectorCSSAgent.cpp:

(SelectorProfile):
(WebCore::SelectorProfile::toInspectorObject):
(WebCore::InspectorCSSAgent::clearFrontend):
(WebCore::InspectorCSSAgent::getMatchedStylesForNode):
(WebCore::InspectorCSSAgent::getInlineStylesForNode):
(WebCore::InspectorCSSAgent::getComputedStyleForNode):
(WebCore::InspectorCSSAgent::getAllStyleSheets):
(WebCore::InspectorCSSAgent::getStyleSheet):
(WebCore::InspectorCSSAgent::setPropertyText):
(WebCore::InspectorCSSAgent::toggleProperty):
(WebCore::InspectorCSSAgent::setRuleSelector):
(WebCore::InspectorCSSAgent::addRule):
(WebCore::InspectorCSSAgent::getSupportedCSSProperties):
(WebCore::InspectorCSSAgent::stopSelectorProfiler):
(WebCore::InspectorCSSAgent::stopSelectorProfilerImpl):
(WebCore::InspectorCSSAgent::collectStyleSheets):
(WebCore::InspectorCSSAgent::buildArrayForRuleList):
(WebCore::InspectorCSSAgent::buildObjectForAttributesStyle):

  • inspector/InspectorCSSAgent.h:

(InspectorCSSAgent):

  • inspector/InspectorStyleSheet.cpp:

(WebCore::buildSourceRangeObject):
(WebCore::buildMediaObject):
(WebCore::fillMediaListChain):
(WebCore::InspectorStyle::buildObjectForStyle):
(WebCore::InspectorStyle::buildArrayForComputedStyle):
(WebCore::InspectorStyle::styleWithProperties):
(WebCore::InspectorStyleSheet::buildObjectForStyleSheet):
(WebCore::InspectorStyleSheet::buildObjectForStyleSheetInfo):
(WebCore::InspectorStyleSheet::buildObjectForRule):
(WebCore::InspectorStyleSheet::buildObjectForStyle):

  • inspector/InspectorStyleSheet.h:

(WebCore::InspectorCSSId::asProtocolValue):
(InspectorStyle):
(InspectorStyleSheet):

Location:
trunk/Source/WebCore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r112083 r112087  
     12012-03-22  Alexander Pavlov  <apavlov@chromium.org>
     2
     3        Web Inspector: Migrate InspectorCSSAgent to strict protocol types
     4        https://bugs.webkit.org/show_bug.cgi?id=81923
     5
     6        Reviewed by Pavel Feldman.
     7
     8        No new tests, as this is a refactoring.
     9
     10        * inspector/CodeGeneratorInspector.py:
     11        * inspector/InspectorCSSAgent.cpp:
     12        (SelectorProfile):
     13        (WebCore::SelectorProfile::toInspectorObject):
     14        (WebCore::InspectorCSSAgent::clearFrontend):
     15        (WebCore::InspectorCSSAgent::getMatchedStylesForNode):
     16        (WebCore::InspectorCSSAgent::getInlineStylesForNode):
     17        (WebCore::InspectorCSSAgent::getComputedStyleForNode):
     18        (WebCore::InspectorCSSAgent::getAllStyleSheets):
     19        (WebCore::InspectorCSSAgent::getStyleSheet):
     20        (WebCore::InspectorCSSAgent::setPropertyText):
     21        (WebCore::InspectorCSSAgent::toggleProperty):
     22        (WebCore::InspectorCSSAgent::setRuleSelector):
     23        (WebCore::InspectorCSSAgent::addRule):
     24        (WebCore::InspectorCSSAgent::getSupportedCSSProperties):
     25        (WebCore::InspectorCSSAgent::stopSelectorProfiler):
     26        (WebCore::InspectorCSSAgent::stopSelectorProfilerImpl):
     27        (WebCore::InspectorCSSAgent::collectStyleSheets):
     28        (WebCore::InspectorCSSAgent::buildArrayForRuleList):
     29        (WebCore::InspectorCSSAgent::buildObjectForAttributesStyle):
     30        * inspector/InspectorCSSAgent.h:
     31        (InspectorCSSAgent):
     32        * inspector/InspectorStyleSheet.cpp:
     33        (WebCore::buildSourceRangeObject):
     34        (WebCore::buildMediaObject):
     35        (WebCore::fillMediaListChain):
     36        (WebCore::InspectorStyle::buildObjectForStyle):
     37        (WebCore::InspectorStyle::buildArrayForComputedStyle):
     38        (WebCore::InspectorStyle::styleWithProperties):
     39        (WebCore::InspectorStyleSheet::buildObjectForStyleSheet):
     40        (WebCore::InspectorStyleSheet::buildObjectForStyleSheetInfo):
     41        (WebCore::InspectorStyleSheet::buildObjectForRule):
     42        (WebCore::InspectorStyleSheet::buildObjectForStyle):
     43        * inspector/InspectorStyleSheet.h:
     44        (WebCore::InspectorCSSId::asProtocolValue):
     45        (InspectorStyle):
     46        (InspectorStyleSheet):
     47
    1482012-03-26  Alexander Pavlov  <apavlov@chromium.org>
    249

  • trunk/Source/WebCore/inspector/CodeGeneratorInspector.py

    r111005 r112087  
    6060                                         "Debugger.FunctionDetails", "Debugger.CallFrame"])
    6161
    62 STRICT_ENABLED_DOMAINS = ["Debugger", "Page"]
     62STRICT_ENABLED_DOMAINS = ["CSS", "Debugger", "Page"]
    6363
    6464

  • trunk/Source/WebCore/inspector/InspectorCSSAgent.cpp

    r110854 r112087  
    4444#include "InspectorHistory.h"
    4545#include "InspectorState.h"
     46#include "InspectorTypeBuilder.h"
    4647#include "InspectorValues.h"
    4748#include "InstrumentingAgents.h"
    … …  
    114115    void commitSelector(bool);
    115116    void commitSelectorTime();
    116     PassRefPtr<InspectorObject> toInspectorObject() const;
     117    PassRefPtr<TypeBuilder::CSS::SelectorProfile> toInspectorObject() const;
    117118
    118119private:
    … …  
    202203}
    203204
    204 PassRefPtr<InspectorObject> SelectorProfile::toInspectorObject() const
    205 {
    206     RefPtr<InspectorArray> selectorProfileData = InspectorArray::create();
     205PassRefPtr<TypeBuilder::CSS::SelectorProfile> SelectorProfile::toInspectorObject() const
     206{
     207    RefPtr<TypeBuilder::Array<TypeBuilder::CSS::SelectorProfileEntry> > selectorProfileData = TypeBuilder::Array<TypeBuilder::CSS::SelectorProfileEntry>::create();
    207208    for (RuleMatchingStatsMap::const_iterator it = m_ruleMatchingStats.begin(); it != m_ruleMatchingStats.end(); ++it) {
    208209        RefPtr<TypeBuilder::CSS::SelectorProfileEntry> entry = TypeBuilder::CSS::SelectorProfileEntry::create()
    … …  
    213214            .setHitCount(it->second.hits)
    214215            .setMatchCount(it->second.matches);
    215         selectorProfileData->pushObject(entry.release());
     216        selectorProfileData->addItem(entry.release());
    216217    }
    217218
    … …  
    489490    clearPseudoState(true);
    490491    String errorString;
    491     stopSelectorProfilerImpl(&errorString);
     492    stopSelectorProfilerImpl(&errorString, false);
    492493}
    493494
    … …  
    563564}
    564565
    565 void InspectorCSSAgent::getMatchedStylesForNode(ErrorString* errorString, int nodeId, const RefPtr<InspectorArray>* forcedPseudoClasses, const bool* needPseudo, const bool* needInherited, RefPtr<InspectorArray>& matchedCSSRules, RefPtr<InspectorArray>& pseudoIdRules, RefPtr<InspectorArray>& inheritedEntries)
     566void InspectorCSSAgent::getMatchedStylesForNode(ErrorString* errorString, int nodeId, const RefPtr<InspectorArray>* forcedPseudoClasses, const bool* includePseudo, const bool* includeInherited, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> >& matchedCSSRules, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::PseudoIdRules> >& pseudoIdRules, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::InheritedStyleEntry> >& inheritedEntries)
    566567{
    567568    Element* element = elementForId(errorString, nodeId);
    … …  
    577578
    578579    // Pseudo elements.
    579     if (!needPseudo || *needPseudo) {
    580         RefPtr<InspectorArray> pseudoElements = InspectorArray::create();
     580    if (!includePseudo || *includePseudo) {
     581        RefPtr<TypeBuilder::Array<TypeBuilder::CSS::PseudoIdRules> > pseudoElements = TypeBuilder::Array<TypeBuilder::CSS::PseudoIdRules>::create();
    581582        for (PseudoId pseudoId = FIRST_PUBLIC_PSEUDOID; pseudoId < AFTER_LAST_INTERNAL_PSEUDOID; pseudoId = static_cast<PseudoId>(pseudoId + 1)) {
    582583            RefPtr<CSSRuleList> matchedRules = selector->pseudoStyleRulesForElement(element, pseudoId, CSSStyleSelector::AllCSSRules);
    583584            if (matchedRules && matchedRules->length()) {
    584                 RefPtr<InspectorObject> pseudoStyles = InspectorObject::create();
    585                 pseudoStyles->setNumber("pseudoId", static_cast<int>(pseudoId));
    586                 pseudoStyles->setArray("rules", buildArrayForRuleList(matchedRules.get()));
    587                 pseudoElements->pushObject(pseudoStyles.release());
     585                RefPtr<TypeBuilder::CSS::PseudoIdRules> pseudoStyles = TypeBuilder::CSS::PseudoIdRules::create()
     586                    .setPseudoId(static_cast<int>(pseudoId))
     587                    .setRules(buildArrayForRuleList(matchedRules.get()));
     588                pseudoElements->addItem(pseudoStyles.release());
    588589            }
    589590        }
    … …  
    593594
    594595    // Inherited styles.
    595     if (!needInherited || *needInherited) {
    596         RefPtr<InspectorArray> inheritedStyles = InspectorArray::create();
     596    if (!includeInherited || *includeInherited) {
     597        RefPtr<TypeBuilder::Array<TypeBuilder::CSS::InheritedStyleEntry> > inheritedStyles = TypeBuilder::Array<TypeBuilder::CSS::InheritedStyleEntry>::create();
    597598        Element* parentElement = element->parentElement();
    598599        while (parentElement) {
    599             RefPtr<InspectorObject> parentStyle = InspectorObject::create();
     600            CSSStyleSelector* parentSelector = parentElement->ownerDocument()->styleSelector();
     601            RefPtr<CSSRuleList> parentMatchedRules = parentSelector->styleRulesForElement(parentElement, CSSStyleSelector::AllCSSRules);
     602            RefPtr<TypeBuilder::CSS::InheritedStyleEntry> parentStyle = TypeBuilder::CSS::InheritedStyleEntry::create()
     603                .setMatchedCSSRules(buildArrayForRuleList(parentMatchedRules.get()));
    600604            if (parentElement->style() && parentElement->style()->length()) {
    601605                InspectorStyleSheetForInlineStyle* styleSheet = asInspectorStyleSheet(parentElement);
    602606                if (styleSheet)
    603                     parentStyle->setObject("inlineStyle", styleSheet->buildObjectForStyle(styleSheet->styleForId(InspectorCSSId(styleSheet->id(), 0))));
     607                    parentStyle->setInlineStyle(styleSheet->buildObjectForStyle(styleSheet->styleForId(InspectorCSSId(styleSheet->id(), 0))));
    604608            }
    605609
    606             CSSStyleSelector* parentSelector = parentElement->ownerDocument()->styleSelector();
    607             RefPtr<CSSRuleList> parentMatchedRules = parentSelector->styleRulesForElement(parentElement, CSSStyleSelector::AllCSSRules);
    608             parentStyle->setArray("matchedCSSRules", buildArrayForRuleList(parentMatchedRules.get()));
    609             inheritedStyles->pushObject(parentStyle.release());
     610            inheritedStyles->addItem(parentStyle.release());
    610611            parentElement = parentElement->parentElement();
    611612        }
    … …  
    615616}
    616617
    617 void InspectorCSSAgent::getInlineStylesForNode(ErrorString* errorString, int nodeId, RefPtr<InspectorObject>& inlineStyle, RefPtr<InspectorObject>& attributesStyle)
     618void InspectorCSSAgent::getInlineStylesForNode(ErrorString* errorString, int nodeId, RefPtr<TypeBuilder::CSS::CSSStyle>& inlineStyle, RefPtr<TypeBuilder::CSS::CSSStyle>& attributesStyle)
    618619{
    619620    Element* element = elementForId(errorString, nodeId);
    … …  
    626627
    627628    inlineStyle = styleSheet->buildObjectForStyle(element->style());
    628     RefPtr<InspectorObject> attributes = buildObjectForAttributesStyle(element);
     629    RefPtr<TypeBuilder::CSS::CSSStyle> attributes = buildObjectForAttributesStyle(element);
    629630    attributesStyle = attributes ? attributes.release() : 0;
    630631}
    631632
    632 void InspectorCSSAgent::getComputedStyleForNode(ErrorString* errorString, int nodeId, const RefPtr<InspectorArray>* forcedPseudoClasses, RefPtr<InspectorArray>& style)
     633void InspectorCSSAgent::getComputedStyleForNode(ErrorString* errorString, int nodeId, const RefPtr<InspectorArray>* forcedPseudoClasses, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSComputedStyleProperty> >& style)
    633634{
    634635    Element* element = elementForId(errorString, nodeId);
    … …  
    643644}
    644645
    645 void InspectorCSSAgent::getAllStyleSheets(ErrorString*, RefPtr<InspectorArray>& styleInfos)
    646 {
     646void InspectorCSSAgent::getAllStyleSheets(ErrorString*, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader> >& styleInfos)
     647{
     648    styleInfos = TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader>::create();
    647649    Vector<Document*> documents = m_domAgent->documents();
    648650    for (Vector<Document*>::iterator it = documents.begin(); it != documents.end(); ++it) {
    … …  
    656658}
    657659
    658 void InspectorCSSAgent::getStyleSheet(ErrorString* errorString, const String& styleSheetId, RefPtr<InspectorObject>& styleSheetObject)
     660void InspectorCSSAgent::getStyleSheet(ErrorString* errorString, const String& styleSheetId, RefPtr<TypeBuilder::CSS::CSSStyleSheetBody>& styleSheetObject)
    659661{
    660662    InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, styleSheetId);
    … …  
    685687}
    686688
    687 void InspectorCSSAgent::setPropertyText(ErrorString* errorString, const RefPtr<InspectorObject>& fullStyleId, int propertyIndex, const String& text, bool overwrite, RefPtr<InspectorObject>& result)
     689void InspectorCSSAgent::setPropertyText(ErrorString* errorString, const RefPtr<InspectorObject>& fullStyleId, int propertyIndex, const String& text, bool overwrite, RefPtr<TypeBuilder::CSS::CSSStyle>& result)
    688690{
    689691    InspectorCSSId compoundId(fullStyleId);
    … …  
    701703}
    702704
    703 void InspectorCSSAgent::toggleProperty(ErrorString* errorString, const RefPtr<InspectorObject>& fullStyleId, int propertyIndex, bool disable, RefPtr<InspectorObject>& result)
     705void InspectorCSSAgent::toggleProperty(ErrorString* errorString, const RefPtr<InspectorObject>& fullStyleId, int propertyIndex, bool disable, RefPtr<TypeBuilder::CSS::CSSStyle>& result)
    704706{
    705707    InspectorCSSId compoundId(fullStyleId);
    … …  
    717719}
    718720
    719 void InspectorCSSAgent::setRuleSelector(ErrorString* errorString, const RefPtr<InspectorObject>& fullRuleId, const String& selector, RefPtr<InspectorObject>& result)
     721void InspectorCSSAgent::setRuleSelector(ErrorString* errorString, const RefPtr<InspectorObject>& fullRuleId, const String& selector, RefPtr<TypeBuilder::CSS::CSSRule>& result)
    720722{
    721723    InspectorCSSId compoundId(fullRuleId);
    … …  
    728730    ExceptionCode ec = 0;
    729731    bool success = m_domAgent->history()->perform(adoptPtr(new SetRuleSelectorAction(inspectorStyleSheet, compoundId, selector)), ec);
    730     if (success)
    731         result = inspectorStyleSheet->buildObjectForStyle(inspectorStyleSheet->styleForId(compoundId));
    732     *errorString = InspectorDOMAgent::toErrorString(ec);
    733732
    734733    if (success)
    735734        result = inspectorStyleSheet->buildObjectForRule(inspectorStyleSheet->ruleForId(compoundId));
    736 }
    737 
    738 void InspectorCSSAgent::addRule(ErrorString* errorString, const int contextNodeId, const String& selector, RefPtr<InspectorObject>& result)
     735    *errorString = InspectorDOMAgent::toErrorString(ec);
     736}
     737
     738void InspectorCSSAgent::addRule(ErrorString* errorString, const int contextNodeId, const String& selector, RefPtr<TypeBuilder::CSS::CSSRule>& result)
    739739{
    740740    Node* node = m_domAgent->assertNode(errorString, contextNodeId);
    … …  
    762762}
    763763
    764 void InspectorCSSAgent::getSupportedCSSProperties(ErrorString*, RefPtr<InspectorArray>& cssProperties)
    765 {
    766     RefPtr<InspectorArray> properties = InspectorArray::create();
     764void InspectorCSSAgent::getSupportedCSSProperties(ErrorString*, RefPtr<TypeBuilder::Array<String> >& cssProperties)
     765{
     766    RefPtr<TypeBuilder::Array<String> > properties = TypeBuilder::Array<String>::create();
    767767    for (int i = 0; i < numCSSProperties; ++i)
    768         properties->pushString(propertyNameStrings[i]);
     768        properties->addItem(propertyNameStrings[i]);
    769769
    770770    cssProperties = properties.release();
    … …  
    777777}
    778778
    779 void InspectorCSSAgent::stopSelectorProfiler(ErrorString* errorString, RefPtr<InspectorObject>& result)
    780 {
    781     stopSelectorProfilerImpl(errorString, &result);
    782 }
    783 
    784 void InspectorCSSAgent::stopSelectorProfilerImpl(ErrorString*, RefPtr<InspectorObject>* result)
     779void InspectorCSSAgent::stopSelectorProfiler(ErrorString* errorString, RefPtr<TypeBuilder::CSS::SelectorProfile>& result)
     780{
     781    result = stopSelectorProfilerImpl(errorString, true);
     782}
     783
     784PassRefPtr<TypeBuilder::CSS::SelectorProfile> InspectorCSSAgent::stopSelectorProfilerImpl(ErrorString*, bool needProfile)
    785785{
    786786    if (!m_state->getBoolean(CSSAgentState::isSelectorProfiling))
    787         return;
     787        return 0;
    788788    m_state->setBoolean(CSSAgentState::isSelectorProfiling, false);
    789     if (m_frontend && result)
    790         *result = m_currentSelectorProfile->toInspectorObject();
     789    RefPtr<TypeBuilder::CSS::SelectorProfile> result;
     790    if (m_frontend && needProfile)
     791        result = m_currentSelectorProfile->toInspectorObject();
    791792    m_currentSelectorProfile.clear();
     793    return result.release();
    792794}
    793795
    … …  
    848850}
    849851
    850 void InspectorCSSAgent::collectStyleSheets(CSSStyleSheet* styleSheet, InspectorArray* result)
     852void InspectorCSSAgent::collectStyleSheets(CSSStyleSheet* styleSheet, TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader>* result)
    851853{
    852854    InspectorStyleSheet* inspectorStyleSheet = bindStyleSheet(static_cast<CSSStyleSheet*>(styleSheet));
    853     result->pushObject(inspectorStyleSheet->buildObjectForStyleSheetInfo());
     855    result->addItem(inspectorStyleSheet->buildObjectForStyleSheetInfo());
    854856    for (unsigned i = 0, size = styleSheet->length(); i < size; ++i) {
    855857        CSSRule* rule = styleSheet->item(i);
    … …  
    947949}
    948950
    949 PassRefPtr<InspectorArray> InspectorCSSAgent::buildArrayForRuleList(CSSRuleList* ruleList)
    950 {
    951     RefPtr<InspectorArray> result = InspectorArray::create();
     951PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > InspectorCSSAgent::buildArrayForRuleList(CSSRuleList* ruleList)
     952{
     953    RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > result = TypeBuilder::Array<TypeBuilder::CSS::CSSRule>::create();
    952954    if (!ruleList)
    953955        return result.release();
    … …  
    960962        InspectorStyleSheet* styleSheet = bindStyleSheet(rule->parentStyleSheet());
    961963        if (styleSheet)
    962             result->pushObject(styleSheet->buildObjectForRule(rule));
     964            result->addItem(styleSheet->buildObjectForRule(rule));
    963965    }
    964966    return result.release();
    965967}
    966968
    967 PassRefPtr<InspectorObject> InspectorCSSAgent::buildObjectForAttributesStyle(Element* element)
     969PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorCSSAgent::buildObjectForAttributesStyle(Element* element)
    968970{
    969971    if (!element->isStyledElement())

  • trunk/Source/WebCore/inspector/InspectorCSSAgent.h

    r109730 r112087  
    9999    void mediaQueryResultChanged();
    100100
    101     virtual void getComputedStyleForNode(ErrorString*, int nodeId, const RefPtr<InspectorArray>* forcedPseudoClasses, RefPtr<InspectorArray>& style);
    102     virtual void getInlineStylesForNode(ErrorString*, int nodeId, RefPtr<InspectorObject>& inlineStyle, RefPtr<InspectorObject>& attributes);
    103     virtual void getMatchedStylesForNode(ErrorString*, int nodeId, const RefPtr<InspectorArray>* forcedPseudoClasses, const bool* includePseudo, const bool* includeInherited, RefPtr<InspectorArray>& matchedCSSRules, RefPtr<InspectorArray>& pseudoIdRules, RefPtr<InspectorArray>& inheritedEntries);
    104     virtual void getAllStyleSheets(ErrorString*, RefPtr<InspectorArray>& styleSheetInfos);
    105     virtual void getStyleSheet(ErrorString*, const String& styleSheetId, RefPtr<InspectorObject>& result);
     101    virtual void getComputedStyleForNode(ErrorString*, int nodeId, const RefPtr<InspectorArray>* forcedPseudoClasses, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSComputedStyleProperty> >&);
     102    virtual void getInlineStylesForNode(ErrorString*, int nodeId, RefPtr<TypeBuilder::CSS::CSSStyle>& inlineStyle, RefPtr<TypeBuilder::CSS::CSSStyle>& attributes);
     103    virtual void getMatchedStylesForNode(ErrorString*, int nodeId, const RefPtr<InspectorArray>* forcedPseudoClasses, const bool* includePseudo, const bool* includeInherited, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> >& matchedCSSRules, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::PseudoIdRules> >& pseudoRules, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::InheritedStyleEntry> >& inheritedEntries);
     104    virtual void getAllStyleSheets(ErrorString*, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader> >& styleSheetInfos);
     105    virtual void getStyleSheet(ErrorString*, const String& styleSheetId, RefPtr<TypeBuilder::CSS::CSSStyleSheetBody>& result);
    106106    virtual void getStyleSheetText(ErrorString*, const String& styleSheetId, String* result);
    107107    virtual void setStyleSheetText(ErrorString*, const String& styleSheetId, const String& text);
    108     virtual void setPropertyText(ErrorString*, const RefPtr<InspectorObject>& styleId, int propertyIndex, const String& text, bool overwrite, RefPtr<InspectorObject>& result);
    109     virtual void toggleProperty(ErrorString*, const RefPtr<InspectorObject>& styleId, int propertyIndex, bool disable, RefPtr<InspectorObject>& result);
    110     virtual void setRuleSelector(ErrorString*, const RefPtr<InspectorObject>& ruleId, const String& selector, RefPtr<InspectorObject>& result);
    111     virtual void addRule(ErrorString*, int contextNodeId, const String& selector, RefPtr<InspectorObject>& result);
    112     virtual void getSupportedCSSProperties(ErrorString*, RefPtr<InspectorArray>& result);
     108    virtual void setPropertyText(ErrorString*, const RefPtr<InspectorObject>& styleId, int propertyIndex, const String& text, bool overwrite, RefPtr<TypeBuilder::CSS::CSSStyle>& result);
     109    virtual void toggleProperty(ErrorString*, const RefPtr<InspectorObject>& styleId, int propertyIndex, bool disable, RefPtr<TypeBuilder::CSS::CSSStyle>& result);
     110    virtual void setRuleSelector(ErrorString*, const RefPtr<InspectorObject>& ruleId, const String& selector, RefPtr<TypeBuilder::CSS::CSSRule>& result);
     111    virtual void addRule(ErrorString*, int contextNodeId, const String& selector, RefPtr<TypeBuilder::CSS::CSSRule>& result);
     112    virtual void getSupportedCSSProperties(ErrorString*, RefPtr<TypeBuilder::Array<String> >& result);
    113113
    114114    virtual void startSelectorProfiler(ErrorString*);
    115     virtual void stopSelectorProfiler(ErrorString*, RefPtr<InspectorObject>&);
     115    virtual void stopSelectorProfiler(ErrorString*, RefPtr<TypeBuilder::CSS::SelectorProfile>&);
    116116
    117     void stopSelectorProfilerImpl(ErrorString*, RefPtr<InspectorObject>* = 0);
     117    PassRefPtr<TypeBuilder::CSS::SelectorProfile> stopSelectorProfilerImpl(ErrorString*, bool needProfile);
    118118    void willMatchRule(const CSSStyleRule*);
    119119    void didMatchRule(bool);
    … …  
    139139    InspectorStyleSheetForInlineStyle* asInspectorStyleSheet(Element* element);
    140140    Element* elementForId(ErrorString*, int nodeId);
    141     void collectStyleSheets(CSSStyleSheet*, InspectorArray*);
     141    void collectStyleSheets(CSSStyleSheet*, TypeBuilder::Array<WebCore::TypeBuilder::CSS::CSSStyleSheetHeader>*);
    142142
    143143    InspectorStyleSheet* bindStyleSheet(CSSStyleSheet*);
    … …  
    146146    String detectOrigin(CSSStyleSheet* pageStyleSheet, Document* ownerDocument);
    147147
    148     PassRefPtr<InspectorArray> buildArrayForRuleList(CSSRuleList* ruleList);
    149     PassRefPtr<InspectorObject> buildObjectForAttributesStyle(Element*);
     148    PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > buildArrayForRuleList(CSSRuleList*);
     149    PassRefPtr<TypeBuilder::CSS::CSSStyle> buildObjectForAttributesStyle(Element*);
    150150
    151151    // InspectorDOMAgent::DOMListener implementation

  • trunk/Source/WebCore/inspector/InspectorStyleSheet.cpp

    r112083 r112087  
    5858#include <wtf/Vector.h>
    5959
     60using WebCore::TypeBuilder::Array;
     61
    6062class ParsedStyleSheet {
    6163public:
    … …  
    116118};
    117119
    118 static PassRefPtr<InspectorObject> buildSourceRangeObject(const SourceRange& range)
    119 {
    120     RefPtr<InspectorObject> result = InspectorObject::create();
    121     result->setNumber("start", range.start);
    122     result->setNumber("end", range.end);
     120static PassRefPtr<TypeBuilder::CSS::SourceRange> buildSourceRangeObject(const SourceRange& range)
     121{
     122    RefPtr<TypeBuilder::CSS::SourceRange> result = TypeBuilder::CSS::SourceRange::create()
     123        .setStart(range.start)
     124        .setEnd(range.end);
    123125    return result.release();
    124126}
    125127
    126 static PassRefPtr<InspectorObject> buildMediaObject(const MediaList* media, MediaListSource mediaListSource, const String& sourceURL)
    127 {
    128     RefPtr<InspectorObject> mediaObject = InspectorObject::create();
     128static PassRefPtr<TypeBuilder::CSS::CSSMedia> buildMediaObject(const MediaList* media, MediaListSource mediaListSource, const String& sourceURL)
     129{
     130    // Make certain compilers happy by initializing |source| up-front.
     131    TypeBuilder::CSS::CSSMedia::Source::Enum source = TypeBuilder::CSS::CSSMedia::Source::InlineSheet;
    129132    switch (mediaListSource) {
    130133    case MediaListSourceMediaRule:
    131         mediaObject->setString("source", "mediaRule");
     134        source = TypeBuilder::CSS::CSSMedia::Source::MediaRule;
    132135        break;
    133136    case MediaListSourceImportRule:
    134         mediaObject->setString("source", "importRule");
     137        source = TypeBuilder::CSS::CSSMedia::Source::ImportRule;
    135138        break;
    136139    case MediaListSourceLinkedSheet:
    137         mediaObject->setString("source", "linkedSheet");
     140        source = TypeBuilder::CSS::CSSMedia::Source::LinkedSheet;
    138141        break;
    139142    case MediaListSourceInlineSheet:
    140         mediaObject->setString("source", "inlineSheet");
     143        source = TypeBuilder::CSS::CSSMedia::Source::InlineSheet;
    141144        break;
    142145    }
     146
     147    RefPtr<TypeBuilder::CSS::CSSMedia> mediaObject = TypeBuilder::CSS::CSSMedia::create()
     148        .setText(media->mediaText())
     149        .setSource(source);
     150
    143151    if (!sourceURL.isEmpty()) {
    144         mediaObject->setString("sourceURL", sourceURL);
    145         mediaObject->setNumber("sourceLine", media->queries()->lastLine());
    146     }
    147     mediaObject->setString("text", media->mediaText());
     152        mediaObject->setSourceURL(sourceURL);
     153        mediaObject->setSourceLine(media->queries()->lastLine());
     154    }
    148155    return mediaObject.release();
    149156}
    … …  
    179186}
    180187
    181 static void fillMediaListChain(CSSRule* rule, InspectorArray* mediaArray)
     188static void fillMediaListChain(CSSRule* rule, Array<TypeBuilder::CSS::CSSMedia>* mediaArray)
    182189{
    183190    MediaList* mediaList;
    … …  
    207214
    208215        if (mediaList && mediaList->length())
    209             mediaArray->pushObject(buildMediaObject(mediaList, isMediaRule ? MediaListSourceMediaRule : MediaListSourceImportRule, sourceURL));
     216            mediaArray->addItem(buildMediaObject(mediaList, isMediaRule ? MediaListSourceMediaRule : MediaListSourceImportRule, sourceURL));
    210217
    211218        if (parentRule->parentRule())
    … …  
    252259}
    253260
    254 PassRefPtr<InspectorObject> InspectorStyle::buildObjectForStyle() const
    255 {
    256     RefPtr<InspectorObject> result = InspectorObject::create();
     261PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorStyle::buildObjectForStyle() const
     262{
     263    RefPtr<TypeBuilder::CSS::CSSStyle> result = styleWithProperties();
    257264    if (!m_styleId.isEmpty())
    258         result->setValue("styleId", m_styleId.asInspectorValue());
    259 
    260     result->setString("width", m_style->getPropertyValue("width"));
    261     result->setString("height", m_style->getPropertyValue("height"));
     265        result->setStyleId(m_styleId.asProtocolValue());
     266
     267    result->setWidth(m_style->getPropertyValue("width"));
     268    result->setHeight(m_style->getPropertyValue("height"));
    262269
    263270    RefPtr<CSSRuleSourceData> sourceData = m_parentStyleSheet ? m_parentStyleSheet->ruleSourceDataFor(m_style.get()) : 0;
    264271    if (sourceData)
    265         result->setObject("range", buildSourceRangeObject(sourceData->styleSourceData->styleBodyRange));
    266 
    267     populateObjectWithStyleProperties(result.get());
     272        result->setRange(buildSourceRangeObject(sourceData->styleSourceData->styleBodyRange));
    268273
    269274    return result.release();
    270275}
    271276
    272 PassRefPtr<InspectorArray> InspectorStyle::buildArrayForComputedStyle() const
    273 {
    274     RefPtr<InspectorArray> result = InspectorArray::create();
     277PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSComputedStyleProperty> > InspectorStyle::buildArrayForComputedStyle() const
     278{
     279    RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSComputedStyleProperty> > result = TypeBuilder::Array<TypeBuilder::CSS::CSSComputedStyleProperty>::create();
    275280    Vector<InspectorStyleProperty> properties;
    276281    populateAllProperties(&properties);
    … …  
    278283    for (Vector<InspectorStyleProperty>::iterator it = properties.begin(), itEnd = properties.end(); it != itEnd; ++it) {
    279284        const CSSPropertySourceData& propertyEntry = it->sourceData;
    280         RefPtr<InspectorObject> entry = InspectorObject::create();
    281         entry->setString("name", propertyEntry.name);
    282         entry->setString("value", propertyEntry.value);
    283         result->pushObject(entry);
     285        RefPtr<TypeBuilder::CSS::CSSComputedStyleProperty> entry = TypeBuilder::CSS::CSSComputedStyleProperty::create()
     286            .setName(propertyEntry.name)
     287            .setValue(propertyEntry.value);
     288        result->addItem(entry);
    284289    }
    285290
    … …  
    458463}
    459464
    460 void InspectorStyle::populateObjectWithStyleProperties(InspectorObject* result) const
     465PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorStyle::styleWithProperties() const
    461466{
    462467    Vector<InspectorStyleProperty> properties;
    463468    populateAllProperties(&properties);
    464469
    465     RefPtr<InspectorArray> propertiesObject = InspectorArray::create();
    466     RefPtr<InspectorArray> shorthandEntries = InspectorArray::create();
    467     HashMap<String, RefPtr<InspectorObject> > propertyNameToPreviousActiveProperty;
     470    RefPtr<Array<TypeBuilder::CSS::CSSProperty> > propertiesObject = Array<TypeBuilder::CSS::CSSProperty>::create();
     471    RefPtr<Array<InspectorObject> > shorthandEntries = Array<InspectorObject>::create();
     472    HashMap<String, RefPtr<TypeBuilder::CSS::CSSProperty> > propertyNameToPreviousActiveProperty;
    468473    HashSet<String> foundShorthands;
    469474
    … …  
    472477        const String& name = propertyEntry.name;
    473478
    474         RefPtr<InspectorObject> property = InspectorObject::create();
    475         propertiesObject->pushObject(property);
    476         String status = it->disabled ? "disabled" : "active";
     479        TypeBuilder::CSS::CSSProperty::Status::Enum status = it->disabled ? TypeBuilder::CSS::CSSProperty::Status::Disabled : TypeBuilder::CSS::CSSProperty::Status::Active;
     480
     481        RefPtr<TypeBuilder::CSS::CSSProperty> property = TypeBuilder::CSS::CSSProperty::create()
     482            .setName(name)
     483            .setValue(propertyEntry.value);
     484
     485        propertiesObject->addItem(property);
    477486
    478487        // Default "parsedOk" == true.
    479488        if (!propertyEntry.parsedOk)
    480             property->setBoolean("parsedOk", false);
     489            property->setParsedOk(false);
    481490        if (it->hasRawText())
    482             property->setString("text", it->rawText);
    483         property->setString("name", name);
    484         property->setString("value", propertyEntry.value);
     491            property->setText(it->rawText);
    485492
    486493        // Default "priority" == "".
    487494        if (propertyEntry.important)
    488             property->setString("priority", "important");
     495            property->setPriority("important");
    489496        if (!it->disabled) {
    490497            if (it->hasSource) {
    491                 property->setBoolean("implicit", false);
    492                 property->setObject("range", buildSourceRangeObject(propertyEntry.range));
     498                property->setImplicit(false);
     499                property->setRange(buildSourceRangeObject(propertyEntry.range));
    493500
    494501                // Parsed property overrides any property with the same name. Non-parsed property overrides
    … …  
    498505                // Canonicalize property names to treat non-prefixed and vendor-prefixed property names the same (opacity vs. -webkit-opacity).
    499506                String canonicalPropertyName = propertyId ? String(getPropertyName(propertyId)) : name;
    500                 HashMap<String, RefPtr<InspectorObject> >::iterator activeIt = propertyNameToPreviousActiveProperty.find(canonicalPropertyName);
     507                HashMap<String, RefPtr<TypeBuilder::CSS::CSSProperty> >::iterator activeIt = propertyNameToPreviousActiveProperty.find(canonicalPropertyName);
    501508                if (activeIt != propertyNameToPreviousActiveProperty.end()) {
    502509                    if (propertyEntry.parsedOk)
    … …  
    512519
    513520                if (shouldInactivate) {
    514                     activeIt->second->setString("status", "inactive");
     521                    activeIt->second->setStatus(TypeBuilder::CSS::CSSProperty::Status::Inactive);
    515522                    activeIt->second->remove("shorthandName");
    516523                    propertyNameToPreviousActiveProperty.set(canonicalPropertyName, property);
    … …  
    520527                // Default "implicit" == false.
    521528                if (implicit)
    522                     property->setBoolean("implicit", true);
    523                 status = "";
     529                    property->setImplicit(true);
     530                status = TypeBuilder::CSS::CSSProperty::Status::Style;
    524531            }
    525532        }
    526533
    527534        // Default "status" == "style".
    528         if (!status.isEmpty())
    529             property->setString("status", status);
     535        if (status != TypeBuilder::CSS::CSSProperty::Status::Style)
     536            property->setStatus(status);
    530537
    531538        if (propertyEntry.parsedOk) {
    … …  
    534541            if (!shorthand.isEmpty()) {
    535542                // Default "shorthandName" == "".
    536                 property->setString("shorthandName", shorthand);
     543                property->setShorthandName(shorthand);
    537544                if (!foundShorthands.contains(shorthand)) {
    538545                    foundShorthands.add(shorthand);
    … …  
    547554    }
    548555
    549     result->setArray("cssProperties", propertiesObject);
    550     result->setArray("shorthandEntries", shorthandEntries);
     556    RefPtr<TypeBuilder::CSS::CSSStyle> result = TypeBuilder::CSS::CSSStyle::create()
     557        .setCssProperties(propertiesObject)
     558        .setShorthandEntries(shorthandEntries);
     559    return result.release();
    551560}
    552561
    … …  
    836845}
    837846
    838 PassRefPtr<InspectorObject> InspectorStyleSheet::buildObjectForStyleSheet()
     847PassRefPtr<TypeBuilder::CSS::CSSStyleSheetBody> InspectorStyleSheet::buildObjectForStyleSheet()
    839848{
    840849    CSSStyleSheet* styleSheet = pageStyleSheet();
    … …  
    842851        return 0;
    843852
    844     RefPtr<InspectorObject> result = InspectorObject::create();
    845     result->setString("styleSheetId", id());
    846853    RefPtr<CSSRuleList> cssRuleList = asCSSRuleList(styleSheet);
    847     RefPtr<InspectorArray> cssRules = buildArrayForRuleList(cssRuleList.get());
    848     result->setArray("rules", cssRules.release());
     854
     855    RefPtr<TypeBuilder::CSS::CSSStyleSheetBody> result = TypeBuilder::CSS::CSSStyleSheetBody::create()
     856        .setStyleSheetId(id())
     857        .setRules(buildArrayForRuleList(cssRuleList.get()));
    849858
    850859    String styleSheetText;
    851860    bool success = getText(&styleSheetText);
    852861    if (success)
    853         result->setString("text", styleSheetText);
     862        result->setText(styleSheetText);
    854863
    855864    return result.release();
    856865}
    857866
    858 PassRefPtr<InspectorObject> InspectorStyleSheet::buildObjectForStyleSheetInfo()
     867PassRefPtr<TypeBuilder::CSS::CSSStyleSheetHeader> InspectorStyleSheet::buildObjectForStyleSheetInfo()
    859868{
    860869    CSSStyleSheet* styleSheet = pageStyleSheet();
    … …  
    862871        return 0;
    863872
    864     RefPtr<InspectorObject> result = InspectorObject::create();
    865     result->setString("styleSheetId", id());
    866     result->setBoolean("disabled", styleSheet->disabled());
    867     result->setString("sourceURL", finalURL());
    868     result->setString("title", styleSheet->title());
     873    RefPtr<TypeBuilder::CSS::CSSStyleSheetHeader> result = TypeBuilder::CSS::CSSStyleSheetHeader::create()
     874        .setStyleSheetId(id())
     875        .setDisabled(styleSheet->disabled())
     876        .setSourceURL(finalURL())
     877        .setTitle(styleSheet->title());
    869878    return result.release();
    870879}
    871880
    872 PassRefPtr<InspectorObject> InspectorStyleSheet::buildObjectForRule(CSSStyleRule* rule)
     881PassRefPtr<TypeBuilder::CSS::CSSRule> InspectorStyleSheet::buildObjectForRule(CSSStyleRule* rule)
    873882{
    874883    CSSStyleSheet* styleSheet = pageStyleSheet();
    … …  
    876885        return 0;
    877886
    878     RefPtr<InspectorObject> result = InspectorObject::create();
    879     result->setString("selectorText", rule->selectorText());
     887    RefPtr<TypeBuilder::CSS::CSSRule> result = TypeBuilder::CSS::CSSRule::create()
     888        .setSelectorText(rule->selectorText())
     889        .setSourceLine(rule->styleRule()->sourceLine())
     890        .setOrigin(m_origin)
     891        .setStyle(buildObjectForStyle(rule->style()));
     892
    880893    // "sourceURL" is present only for regular rules, otherwise "origin" should be used in the frontend.
    881894    if (m_origin == "regular")
    882         result->setString("sourceURL", finalURL());
    883     result->setNumber("sourceLine", rule->styleRule()->sourceLine());
    884     result->setString("origin", m_origin);
    885 
    886     result->setObject("style", buildObjectForStyle(rule->style()));
     895        result->setSourceURL(finalURL());
     896
    887897    if (canBind()) {
    888898        InspectorCSSId id(ruleId(rule));
    889899        if (!id.isEmpty())
    890             result->setValue("ruleId", id.asInspectorValue());
     900            result->setRuleId(id.asProtocolValue());
    891901    }
    892902
    … …  
    895905        sourceData = ruleSourceDataFor(rule->style());
    896906    if (sourceData) {
    897         RefPtr<InspectorObject> selectorRange = InspectorObject::create();
    898         selectorRange->setNumber("start", sourceData->selectorListRange.start);
    899         selectorRange->setNumber("end", sourceData->selectorListRange.end);
    900         result->setObject("selectorRange", selectorRange.release());
    901     }
    902 
    903     RefPtr<InspectorArray> mediaArray = InspectorArray::create();
     907        RefPtr<TypeBuilder::CSS::SourceRange> selectorRange = TypeBuilder::CSS::SourceRange::create()
     908            .setStart(sourceData->selectorListRange.start)
     909            .setEnd(sourceData->selectorListRange.end);
     910        result->setSelectorRange(selectorRange.release());
     911    }
     912
     913    RefPtr<Array<TypeBuilder::CSS::CSSMedia> > mediaArray = Array<TypeBuilder::CSS::CSSMedia>::create();
    904914
    905915    fillMediaListChain(rule, mediaArray.get());
    906916    if (mediaArray->length())
    907         result->setArray("media", mediaArray.release());
     917        result->setMedia(mediaArray.release());
    908918
    909919    return result.release();
    910920}
    911921
    912 PassRefPtr<InspectorObject> InspectorStyleSheet::buildObjectForStyle(CSSStyleDeclaration* style)
     922PassRefPtr<TypeBuilder::CSS::CSSStyle> InspectorStyleSheet::buildObjectForStyle(CSSStyleDeclaration* style)
    913923{
    914924    RefPtr<CSSRuleSourceData> sourceData;
    … …  
    918928    InspectorCSSId id = ruleOrStyleId(style);
    919929    if (id.isEmpty()) {
    920         RefPtr<InspectorObject> bogusStyle = InspectorObject::create();
    921         bogusStyle->setArray("cssProperties", InspectorArray::create());
    922         bogusStyle->setObject("shorthandEntries", InspectorObject::create());
     930        RefPtr<TypeBuilder::CSS::CSSStyle> bogusStyle = TypeBuilder::CSS::CSSStyle::create()
     931            .setCssProperties(Array<TypeBuilder::CSS::CSSProperty>::create())
     932            .setShorthandEntries(Array<InspectorObject>::create());
    923933        return bogusStyle.release();
    924934    }
    925935    RefPtr<InspectorStyle> inspectorStyle = inspectorStyleForId(id);
    926     RefPtr<InspectorObject> result = inspectorStyle->buildObjectForStyle();
     936    RefPtr<TypeBuilder::CSS::CSSStyle> result = inspectorStyle->buildObjectForStyle();
    927937
    928938    // Style text cannot be retrieved without stylesheet, so set cssText here.
    … …  
    932942        if (success) {
    933943            const SourceRange& bodyRange = sourceData->styleSourceData->styleBodyRange;
    934             result->setString("cssText", sheetText.substring(bodyRange.start, bodyRange.end - bodyRange.start));
     944            result->setCssText(sheetText.substring(bodyRange.start, bodyRange.end - bodyRange.start));
    935945        }
    936946    }

  • trunk/Source/WebCore/inspector/InspectorStyleSheet.h

    r108391 r112087  
    3030#include "ExceptionCode.h"
    3131#include "InspectorStyleTextEditor.h"
     32#include "InspectorTypeBuilder.h"
    3233#include "InspectorValues.h"
    3334#include "PlatformString.h"
    … …  
    8081    unsigned ordinal() const { return m_ordinal; }
    8182
    82     PassRefPtr<InspectorValue> asInspectorValue() const
     83    PassRefPtr<TypeBuilder::CSS::CSSStyleId> asProtocolValue() const
    8384    {
    8485        if (isEmpty())
    85             return InspectorValue::null();
    86 
    87         RefPtr<InspectorObject> result = InspectorObject::create();
    88         result->setString("styleSheetId", m_styleSheetId);
    89         result->setNumber("ordinal", m_ordinal);
     86            return 0;
     87
     88        RefPtr<TypeBuilder::CSS::CSSStyleId> result = TypeBuilder::CSS::CSSStyleId::create()
     89            .setStyleSheetId(m_styleSheetId)
     90            .setOrdinal(m_ordinal);
    9091        return result.release();
    9192    }
    … …  
    131132
    132133    CSSStyleDeclaration* cssStyle() const { return m_style.get(); }
    133     PassRefPtr<InspectorObject> buildObjectForStyle() const;
    134     PassRefPtr<InspectorArray> buildArrayForComputedStyle() const;
     134    PassRefPtr<TypeBuilder::CSS::CSSStyle> buildObjectForStyle() const;
     135    PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSComputedStyleProperty> > buildArrayForComputedStyle() const;
    135136    bool hasDisabledProperties() const { return !m_disabledProperties.isEmpty(); }
    136137    bool setPropertyText(unsigned index, const String& text, bool overwrite, String* oldText, ExceptionCode&);
    … …  
    142143    bool styleText(String* result) const;
    143144    bool populateAllProperties(Vector<InspectorStyleProperty>* result) const;
    144     void populateObjectWithStyleProperties(InspectorObject* result) const;
     145    PassRefPtr<TypeBuilder::CSS::CSSStyle> styleWithProperties() const;
    145146    bool applyStyleText(const String&);
    146147    String shorthandValue(const String& shorthandProperty) const;
    … …  
    182183    bool deleteRule(const InspectorCSSId&, ExceptionCode&);
    183184    CSSStyleRule* ruleForId(const InspectorCSSId&) const;
    184     PassRefPtr<InspectorObject> buildObjectForStyleSheet();
    185     PassRefPtr<InspectorObject> buildObjectForStyleSheetInfo();
    186     PassRefPtr<InspectorObject> buildObjectForRule(CSSStyleRule*);
    187     PassRefPtr<InspectorObject> buildObjectForStyle(CSSStyleDeclaration*);
     185    PassRefPtr<TypeBuilder::CSS::CSSStyleSheetBody> buildObjectForStyleSheet();
     186    PassRefPtr<TypeBuilder::CSS::CSSStyleSheetHeader> buildObjectForStyleSheetInfo();
     187    PassRefPtr<TypeBuilder::CSS::CSSRule> buildObjectForRule(CSSStyleRule*);
     188    PassRefPtr<TypeBuilder::CSS::CSSStyle> buildObjectForStyle(CSSStyleDeclaration*);
    188189    bool setPropertyText(const InspectorCSSId&, unsigned propertyIndex, const String& text, bool overwrite, String* oldPropertyText, ExceptionCode&);
    189190    bool toggleProperty(const InspectorCSSId&, unsigned propertyIndex, bool disable, ExceptionCode&);
Note: See TracChangeset for help on using the changeset viewer.