Home | History | Annotate | Download | only in inspector 
      1 /*
      2  * Copyright (C) 2010, Google Inc. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  * 1.  Redistributions of source code must retain the above copyright
      8  *     notice, this list of conditions and the following disclaimer.
      9  * 2.  Redistributions in binary form must reproduce the above copyright
     10  *     notice, this list of conditions and the following disclaimer in the
     11  *     documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
     16  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
     17  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
     18  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     19  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
     20  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     22  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     23  */
     24 
     25 #include "config.h"
     26 #include "InspectorCSSAgent.h"
     27 
     28 #if ENABLE(INSPECTOR)
     29 
     30 #include "CSSComputedStyleDeclaration.h"
     31 #include "CSSMutableStyleDeclaration.h"
     32 #include "CSSPropertyNames.h"
     33 #include "CSSPropertySourceData.h"
     34 #include "CSSRule.h"
     35 #include "CSSRuleList.h"
     36 #include "CSSStyleRule.h"
     37 #include "CSSStyleSelector.h"
     38 #include "CSSStyleSheet.h"
     39 #include "DOMWindow.h"
     40 #include "HTMLHeadElement.h"
     41 #include "InspectorDOMAgent.h"
     42 #include "InspectorValues.h"
     43 #include "InstrumentingAgents.h"
     44 #include "Node.h"
     45 #include "NodeList.h"
     46 #include "StyleSheetList.h"
     47 
     48 #include <wtf/HashSet.h>
     49 #include <wtf/Vector.h>
     50 #include <wtf/text/CString.h>
     51 
     52 // Currently implemented model:
     53 //
     54 // cssProperty = {
     55 //    name          : <string>,
     56 //    value         : <string>,
     57 //    priority      : <string>, // "" for non-parsedOk properties
     58 //    implicit      : <boolean>,
     59 //    parsedOk      : <boolean>, // whether property is understood by WebCore
     60 //    status        : <string>, // "disabled" | "active" | "inactive" | "style"
     61 //    shorthandName : <string>,
     62 //    startOffset   : <number>, // Optional - property text start offset in enclosing style declaration. Absent for computed styles and such.
     63 //    endOffset     : <number>, // Optional - property text end offset in enclosing style declaration. Absent for computed styles and such.
     64 // }
     65 //
     66 // name + value + priority : present when the property is enabled
     67 // text                    : present when the property is disabled
     68 //
     69 // For disabled properties, startOffset === endOffset === insertion point for the property.
     70 //
     71 // status:
     72 // "disabled" == property disabled by user
     73 // "active" == property participates in the computed style calculation
     74 // "inactive" == property does no participate in the computed style calculation (i.e. overridden by a subsequent property with the same name)
     75 // "style" == property is active and originates from the WebCore CSSStyleDeclaration rather than CSS source code (e.g. implicit longhand properties)
     76 //
     77 // cssStyle = {
     78 //    styleId            : <string>, // Optional
     79 //    cssProperties      : [
     80 //                          #cssProperty,
     81 //                          ...
     82 //                          #cssProperty
     83 //                         ],
     84 //    shorthandEntries   : [
     85 //                          #shorthandEntry,
     86 //                          ...
     87 //                          #shorthandEntry
     88 //                         ],
     89 //    cssText            : <string>, // Optional - declaration text
     90 //    properties         : {
     91 //                          width,
     92 //                          height,
     93 //                          startOffset, // Optional - for source-based styles only
     94 //                          endOffset, // Optional - for source-based styles only
     95 //                         }
     96 // }
     97 //
     98 // shorthandEntry = {
     99 //    name: <string>,
    100 //    value: <string>
    101 // }
    102 //
    103 // cssRule = {
    104 //    ruleId       : <string>, // Optional
    105 //    selectorText : <string>,
    106 //    sourceURL    : <string>,
    107 //    sourceLine   : <string>,
    108 //    origin       : <string>, // "" || "user-agent" || "user" || "inspector"
    109 //    style        : #cssStyle,
    110 //    selectorRange: { start: <number>, end: <number> } // Optional - for source-based rules only
    111 // }
    112 //
    113 // cssStyleSheetInfo = {
    114 //    styleSheetId : <number>
    115 //    sourceURL    : <string>
    116 //    title        : <string>
    117 //    disabled     : <boolean>
    118 // }
    119 //
    120 // cssStyleSheet = {
    121 //    styleSheetId : <number>
    122 //    rules        : [
    123 //                       #cssRule,
    124 //                       ...
    125 //                       #cssRule
    126 //                   ]
    127 //    text         : <string> // Optional - whenever the text is available for a text-based stylesheet
    128 // }
    129 
    130 namespace WebCore {
    131 
    132 // static
    133 CSSStyleSheet* InspectorCSSAgent::parentStyleSheet(StyleBase* styleBase)
    134 {
    135     if (!styleBase)
    136         return 0;
    137 
    138     StyleSheet* styleSheet = styleBase->stylesheet();
    139     if (styleSheet && styleSheet->isCSSStyleSheet())
    140         return static_cast<CSSStyleSheet*>(styleSheet);
    141 
    142     return 0;
    143 }
    144 
    145 // static
    146 CSSStyleRule* InspectorCSSAgent::asCSSStyleRule(StyleBase* styleBase)
    147 {
    148     if (!styleBase->isStyleRule())
    149         return 0;
    150     CSSRule* rule = static_cast<CSSRule*>(styleBase);
    151     if (rule->type() != CSSRule::STYLE_RULE)
    152         return 0;
    153     return static_cast<CSSStyleRule*>(rule);
    154 }
    155 
    156 InspectorCSSAgent::InspectorCSSAgent(InstrumentingAgents* instrumentingAgents, InspectorDOMAgent* domAgent)
    157     : m_instrumentingAgents(instrumentingAgents)
    158     , m_domAgent(domAgent)
    159     , m_lastStyleSheetId(1)
    160     , m_lastRuleId(1)
    161     , m_lastStyleId(1)
    162 {
    163     m_domAgent->setDOMListener(this);
    164     m_instrumentingAgents->setInspectorCSSAgent(this);
    165 }
    166 
    167 InspectorCSSAgent::~InspectorCSSAgent()
    168 {
    169     m_instrumentingAgents->setInspectorCSSAgent(0);
    170     // DOM agent should be destroyed after CSS agent.
    171     m_domAgent->setDOMListener(0);
    172     m_domAgent = 0;
    173     reset();
    174 }
    175 
    176 void InspectorCSSAgent::reset()
    177 {
    178     m_idToInspectorStyleSheet.clear();
    179     m_cssStyleSheetToInspectorStyleSheet.clear();
    180     m_nodeToInspectorStyleSheet.clear();
    181     m_documentToInspectorStyleSheet.clear();
    182 }
    183 
    184 void InspectorCSSAgent::getStylesForNode(ErrorString* errorString, int nodeId, RefPtr<InspectorObject>* result)
    185 {
    186     Element* element = elementForId(errorString, nodeId);
    187     if (!element)
    188         return;
    189 
    190     RefPtr<InspectorObject> resultObject = InspectorObject::create();
    191 
    192     InspectorStyleSheetForInlineStyle* styleSheet = asInspectorStyleSheet(element);
    193     if (styleSheet)
    194         resultObject->setObject("inlineStyle", styleSheet->buildObjectForStyle(element->style()));
    195 
    196     RefPtr<CSSComputedStyleDeclaration> computedStyleInfo = computedStyle(element, true); // Support the viewing of :visited information in computed style.
    197     RefPtr<InspectorStyle> computedInspectorStyle = InspectorStyle::create(InspectorCSSId(), computedStyleInfo, 0);
    198     resultObject->setObject("computedStyle", computedInspectorStyle->buildObjectForStyle());
    199 
    200     CSSStyleSelector* selector = element->ownerDocument()->styleSelector();
    201     RefPtr<CSSRuleList> matchedRules = selector->styleRulesForElement(element, false, true);
    202     resultObject->setArray("matchedCSSRules", buildArrayForRuleList(matchedRules.get()));
    203 
    204     resultObject->setArray("styleAttributes", buildArrayForAttributeStyles(element));
    205 
    206     RefPtr<InspectorArray> pseudoElements = InspectorArray::create();
    207     for (PseudoId pseudoId = FIRST_PUBLIC_PSEUDOID; pseudoId < AFTER_LAST_INTERNAL_PSEUDOID; pseudoId = static_cast<PseudoId>(pseudoId + 1)) {
    208         RefPtr<CSSRuleList> matchedRules = selector->pseudoStyleRulesForElement(element, pseudoId, false, true);
    209         if (matchedRules && matchedRules->length()) {
    210             RefPtr<InspectorObject> pseudoStyles = InspectorObject::create();
    211             pseudoStyles->setNumber("pseudoId", static_cast<int>(pseudoId));
    212             pseudoStyles->setArray("rules", buildArrayForRuleList(matchedRules.get()));
    213             pseudoElements->pushObject(pseudoStyles.release());
    214         }
    215     }
    216     resultObject->setArray("pseudoElements", pseudoElements.release());
    217 
    218     RefPtr<InspectorArray> inheritedStyles = InspectorArray::create();
    219     Element* parentElement = element->parentElement();
    220     while (parentElement) {
    221         RefPtr<InspectorObject> parentStyle = InspectorObject::create();
    222         if (parentElement->style() && parentElement->style()->length()) {
    223             InspectorStyleSheetForInlineStyle* styleSheet = asInspectorStyleSheet(parentElement);
    224             if (styleSheet)
    225                 parentStyle->setObject("inlineStyle", styleSheet->buildObjectForStyle(styleSheet->styleForId(InspectorCSSId(styleSheet->id(), 0))));
    226         }
    227 
    228         CSSStyleSelector* parentSelector = parentElement->ownerDocument()->styleSelector();
    229         RefPtr<CSSRuleList> parentMatchedRules = parentSelector->styleRulesForElement(parentElement, false, true);
    230         parentStyle->setArray("matchedCSSRules", buildArrayForRuleList(parentMatchedRules.get()));
    231         inheritedStyles->pushObject(parentStyle.release());
    232         parentElement = parentElement->parentElement();
    233     }
    234     resultObject->setArray("inherited", inheritedStyles.release());
    235 
    236     *result = resultObject.release();
    237 }
    238 
    239 void InspectorCSSAgent::getInlineStyleForNode(ErrorString* errorString, int nodeId, RefPtr<InspectorObject>* style)
    240 {
    241     Element* element = elementForId(errorString, nodeId);
    242     if (!element)
    243         return;
    244 
    245     InspectorStyleSheetForInlineStyle* styleSheet = asInspectorStyleSheet(element);
    246     if (!styleSheet)
    247         return;
    248 
    249     *style = styleSheet->buildObjectForStyle(element->style());
    250 }
    251 
    252 void InspectorCSSAgent::getComputedStyleForNode(ErrorString* errorString, int nodeId, RefPtr<InspectorObject>* style)
    253 {
    254     Element* element = elementForId(errorString, nodeId);
    255     if (!element)
    256         return;
    257 
    258     RefPtr<CSSComputedStyleDeclaration> computedStyleInfo = computedStyle(element, true);
    259     RefPtr<InspectorStyle> inspectorStyle = InspectorStyle::create(InspectorCSSId(), computedStyleInfo, 0);
    260     *style = inspectorStyle->buildObjectForStyle();
    261 }
    262 
    263 void InspectorCSSAgent::getAllStyleSheets(ErrorString*, RefPtr<InspectorArray>* styleInfos)
    264 {
    265     Vector<Document*> documents = m_domAgent->documents();
    266     for (Vector<Document*>::iterator it = documents.begin(); it != documents.end(); ++it) {
    267         StyleSheetList* list = (*it)->styleSheets();
    268         for (unsigned i = 0; i < list->length(); ++i) {
    269             StyleSheet* styleSheet = list->item(i);
    270             if (styleSheet->isCSSStyleSheet()) {
    271                 InspectorStyleSheet* inspectorStyleSheet = bindStyleSheet(static_cast<CSSStyleSheet*>(styleSheet));
    272                 (*styleInfos)->pushObject(inspectorStyleSheet->buildObjectForStyleSheetInfo());
    273             }
    274         }
    275     }
    276 }
    277 
    278 void InspectorCSSAgent::getStyleSheet(ErrorString* errorString, const String& styleSheetId, RefPtr<InspectorObject>* styleSheetObject)
    279 {
    280     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, styleSheetId);
    281     if (!inspectorStyleSheet)
    282         return;
    283 
    284     *styleSheetObject = inspectorStyleSheet->buildObjectForStyleSheet();
    285 }
    286 
    287 void InspectorCSSAgent::getStyleSheetText(ErrorString* errorString, const String& styleSheetId, String* result)
    288 {
    289     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, styleSheetId);
    290     if (!inspectorStyleSheet)
    291         return;
    292 
    293     inspectorStyleSheet->text(result);
    294 }
    295 
    296 void InspectorCSSAgent::setStyleSheetText(ErrorString* errorString, const String& styleSheetId, const String& text)
    297 {
    298     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, styleSheetId);
    299     if (!inspectorStyleSheet)
    300         return;
    301 
    302     if (inspectorStyleSheet->setText(text))
    303         inspectorStyleSheet->reparseStyleSheet(text);
    304     else
    305         *errorString = "Internal error setting style sheet text";
    306 }
    307 
    308 void InspectorCSSAgent::setPropertyText(ErrorString* errorString, const RefPtr<InspectorObject>& fullStyleId, int propertyIndex, const String& text, bool overwrite, RefPtr<InspectorObject>* result)
    309 {
    310     InspectorCSSId compoundId(fullStyleId);
    311     ASSERT(!compoundId.isEmpty());
    312 
    313     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, compoundId.styleSheetId());
    314     if (!inspectorStyleSheet)
    315         return;
    316 
    317     bool success = inspectorStyleSheet->setPropertyText(errorString, compoundId, propertyIndex, text, overwrite);
    318     if (success)
    319         *result = inspectorStyleSheet->buildObjectForStyle(inspectorStyleSheet->styleForId(compoundId));
    320 }
    321 
    322 void InspectorCSSAgent::toggleProperty(ErrorString* errorString, const RefPtr<InspectorObject>& fullStyleId, int propertyIndex, bool disable, RefPtr<InspectorObject>* result)
    323 {
    324     InspectorCSSId compoundId(fullStyleId);
    325     ASSERT(!compoundId.isEmpty());
    326 
    327     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, compoundId.styleSheetId());
    328     if (!inspectorStyleSheet)
    329         return;
    330 
    331     bool success = inspectorStyleSheet->toggleProperty(errorString, compoundId, propertyIndex, disable);
    332     if (success)
    333         *result = inspectorStyleSheet->buildObjectForStyle(inspectorStyleSheet->styleForId(compoundId));
    334 }
    335 
    336 void InspectorCSSAgent::setRuleSelector(ErrorString* errorString, const RefPtr<InspectorObject>& fullRuleId, const String& selector, RefPtr<InspectorObject>* result)
    337 {
    338     InspectorCSSId compoundId(fullRuleId);
    339     ASSERT(!compoundId.isEmpty());
    340 
    341     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, compoundId.styleSheetId());
    342     if (!inspectorStyleSheet)
    343         return;
    344 
    345     bool success = inspectorStyleSheet->setRuleSelector(compoundId, selector);
    346     if (!success)
    347         return;
    348 
    349     *result = inspectorStyleSheet->buildObjectForRule(inspectorStyleSheet->ruleForId(compoundId));
    350 }
    351 
    352 void InspectorCSSAgent::addRule(ErrorString*, const int contextNodeId, const String& selector, RefPtr<InspectorObject>* result)
    353 {
    354     Node* node = m_domAgent->nodeForId(contextNodeId);
    355     if (!node)
    356         return;
    357 
    358     InspectorStyleSheet* inspectorStyleSheet = viaInspectorStyleSheet(node->document(), true);
    359     if (!inspectorStyleSheet)
    360         return;
    361     CSSStyleRule* newRule = inspectorStyleSheet->addRule(selector);
    362     if (!newRule)
    363         return;
    364 
    365     *result = inspectorStyleSheet->buildObjectForRule(newRule);
    366 }
    367 
    368 void InspectorCSSAgent::getSupportedCSSProperties(ErrorString*, RefPtr<InspectorArray>* cssProperties)
    369 {
    370     RefPtr<InspectorArray> properties = InspectorArray::create();
    371     for (int i = 0; i < numCSSProperties; ++i)
    372         properties->pushString(propertyNameStrings[i]);
    373 
    374     *cssProperties = properties.release();
    375 }
    376 
    377 // static
    378 Element* InspectorCSSAgent::inlineStyleElement(CSSStyleDeclaration* style)
    379 {
    380     if (!style || !style->isMutableStyleDeclaration())
    381         return 0;
    382     Node* node = static_cast<CSSMutableStyleDeclaration*>(style)->node();
    383     if (!node || !node->isStyledElement() || static_cast<StyledElement*>(node)->getInlineStyleDecl() != style)
    384         return 0;
    385     return static_cast<Element*>(node);
    386 }
    387 
    388 InspectorStyleSheetForInlineStyle* InspectorCSSAgent::asInspectorStyleSheet(Element* element)
    389 {
    390     NodeToInspectorStyleSheet::iterator it = m_nodeToInspectorStyleSheet.find(element);
    391     if (it == m_nodeToInspectorStyleSheet.end()) {
    392         CSSStyleDeclaration* style = element->isStyledElement() ? element->style() : 0;
    393         if (!style)
    394             return 0;
    395 
    396         String newStyleSheetId = String::number(m_lastStyleSheetId++);
    397         RefPtr<InspectorStyleSheetForInlineStyle> inspectorStyleSheet = InspectorStyleSheetForInlineStyle::create(newStyleSheetId, element, "");
    398         m_idToInspectorStyleSheet.set(newStyleSheetId, inspectorStyleSheet);
    399         m_nodeToInspectorStyleSheet.set(element, inspectorStyleSheet);
    400         return inspectorStyleSheet.get();
    401     }
    402 
    403     return it->second.get();
    404 }
    405 
    406 Element* InspectorCSSAgent::elementForId(ErrorString* errorString, int nodeId)
    407 {
    408     Node* node = m_domAgent->nodeForId(nodeId);
    409     if (!node) {
    410         *errorString = "No node with given id found";
    411         return 0;
    412     }
    413     if (node->nodeType() != Node::ELEMENT_NODE) {
    414         *errorString = "Not an element node";
    415         return 0;
    416     }
    417     return static_cast<Element*>(node);
    418 }
    419 
    420 InspectorStyleSheet* InspectorCSSAgent::bindStyleSheet(CSSStyleSheet* styleSheet)
    421 {
    422     RefPtr<InspectorStyleSheet> inspectorStyleSheet = m_cssStyleSheetToInspectorStyleSheet.get(styleSheet);
    423     if (!inspectorStyleSheet) {
    424         String id = String::number(m_lastStyleSheetId++);
    425         inspectorStyleSheet = InspectorStyleSheet::create(id, styleSheet, detectOrigin(styleSheet, styleSheet->document()), m_domAgent->documentURLString(styleSheet->document()));
    426         m_idToInspectorStyleSheet.set(id, inspectorStyleSheet);
    427         m_cssStyleSheetToInspectorStyleSheet.set(styleSheet, inspectorStyleSheet);
    428     }
    429     return inspectorStyleSheet.get();
    430 }
    431 
    432 InspectorStyleSheet* InspectorCSSAgent::viaInspectorStyleSheet(Document* document, bool createIfAbsent)
    433 {
    434     if (!document) {
    435         ASSERT(!createIfAbsent);
    436         return 0;
    437     }
    438 
    439     RefPtr<InspectorStyleSheet> inspectorStyleSheet = m_documentToInspectorStyleSheet.get(document);
    440     if (inspectorStyleSheet || !createIfAbsent)
    441         return inspectorStyleSheet.get();
    442 
    443     ExceptionCode ec = 0;
    444     RefPtr<Element> styleElement = document->createElement("style", ec);
    445     if (!ec)
    446         styleElement->setAttribute("type", "text/css", ec);
    447     if (!ec) {
    448         ContainerNode* targetNode;
    449         // HEAD is absent in ImageDocuments, for example.
    450         if (document->head())
    451             targetNode = document->head();
    452         else if (document->body())
    453             targetNode = document->body();
    454         else
    455             return 0;
    456         targetNode->appendChild(styleElement, ec);
    457     }
    458     if (ec)
    459         return 0;
    460     StyleSheetList* styleSheets = document->styleSheets();
    461     StyleSheet* styleSheet = styleSheets->item(styleSheets->length() - 1);
    462     if (!styleSheet->isCSSStyleSheet())
    463         return 0;
    464     CSSStyleSheet* cssStyleSheet = static_cast<CSSStyleSheet*>(styleSheet);
    465     String id = String::number(m_lastStyleSheetId++);
    466     inspectorStyleSheet = InspectorStyleSheet::create(id, cssStyleSheet, "inspector", m_domAgent->documentURLString(document));
    467     m_idToInspectorStyleSheet.set(id, inspectorStyleSheet);
    468     m_cssStyleSheetToInspectorStyleSheet.set(cssStyleSheet, inspectorStyleSheet);
    469     m_documentToInspectorStyleSheet.set(document, inspectorStyleSheet);
    470     return inspectorStyleSheet.get();
    471 }
    472 
    473 InspectorStyleSheet* InspectorCSSAgent::assertStyleSheetForId(ErrorString* errorString, const String& styleSheetId)
    474 {
    475     IdToInspectorStyleSheet::iterator it = m_idToInspectorStyleSheet.find(styleSheetId);
    476     if (it == m_idToInspectorStyleSheet.end()) {
    477         *errorString = "No style sheet with given id found";
    478         return 0;
    479     }
    480     return it->second.get();
    481 }
    482 
    483 String InspectorCSSAgent::detectOrigin(CSSStyleSheet* pageStyleSheet, Document* ownerDocument)
    484 {
    485     DEFINE_STATIC_LOCAL(String, userAgent, ("user-agent"));
    486     DEFINE_STATIC_LOCAL(String, user, ("user"));
    487     DEFINE_STATIC_LOCAL(String, inspector, ("inspector"));
    488 
    489     String origin("");
    490     if (pageStyleSheet && !pageStyleSheet->ownerNode() && pageStyleSheet->href().isEmpty())
    491         origin = userAgent;
    492     else if (pageStyleSheet && pageStyleSheet->ownerNode() && pageStyleSheet->ownerNode()->nodeName() == "#document")
    493         origin = user;
    494     else {
    495         InspectorStyleSheet* viaInspectorStyleSheetForOwner = viaInspectorStyleSheet(ownerDocument, false);
    496         if (viaInspectorStyleSheetForOwner && pageStyleSheet == viaInspectorStyleSheetForOwner->pageStyleSheet())
    497             origin = inspector;
    498     }
    499     return origin;
    500 }
    501 
    502 PassRefPtr<InspectorArray> InspectorCSSAgent::buildArrayForRuleList(CSSRuleList* ruleList)
    503 {
    504     RefPtr<InspectorArray> result = InspectorArray::create();
    505     if (!ruleList)
    506         return result.release();
    507 
    508     for (unsigned i = 0, size = ruleList->length(); i < size; ++i) {
    509         CSSStyleRule* rule = asCSSStyleRule(ruleList->item(i));
    510         if (!rule)
    511             continue;
    512 
    513         InspectorStyleSheet* styleSheet = bindStyleSheet(parentStyleSheet(rule));
    514         if (styleSheet)
    515             result->pushObject(styleSheet->buildObjectForRule(rule));
    516     }
    517     return result.release();
    518 }
    519 
    520 PassRefPtr<InspectorArray> InspectorCSSAgent::buildArrayForAttributeStyles(Element* element)
    521 {
    522     RefPtr<InspectorArray> attrStyles = InspectorArray::create();
    523     NamedNodeMap* attributes = element->attributes();
    524     for (unsigned i = 0; attributes && i < attributes->length(); ++i) {
    525         Attribute* attribute = attributes->attributeItem(i);
    526         if (attribute->style()) {
    527             RefPtr<InspectorObject> attrStyleObject = InspectorObject::create();
    528             String attributeName = attribute->localName();
    529             RefPtr<InspectorStyle> inspectorStyle = InspectorStyle::create(InspectorCSSId(), attribute->style(), 0);
    530             attrStyleObject->setString("name", attributeName.utf8().data());
    531             attrStyleObject->setObject("style", inspectorStyle->buildObjectForStyle());
    532             attrStyles->pushObject(attrStyleObject.release());
    533         }
    534     }
    535 
    536     return attrStyles.release();
    537 }
    538 
    539 void InspectorCSSAgent::didRemoveDocument(Document* document)
    540 {
    541     if (document)
    542         m_documentToInspectorStyleSheet.remove(document);
    543 }
    544 
    545 void InspectorCSSAgent::didRemoveDOMNode(Node* node)
    546 {
    547     if (!node)
    548         return;
    549 
    550     NodeToInspectorStyleSheet::iterator it = m_nodeToInspectorStyleSheet.find(node);
    551     if (it == m_nodeToInspectorStyleSheet.end())
    552         return;
    553 
    554     m_idToInspectorStyleSheet.remove(it->second->id());
    555     m_nodeToInspectorStyleSheet.remove(node);
    556 }
    557 
    558 void InspectorCSSAgent::didModifyDOMAttr(Element* element)
    559 {
    560     if (!element)
    561         return;
    562 
    563     NodeToInspectorStyleSheet::iterator it = m_nodeToInspectorStyleSheet.find(element);
    564     if (it == m_nodeToInspectorStyleSheet.end())
    565         return;
    566 
    567     it->second->didModifyElementAttribute();
    568 }
    569 
    570 } // namespace WebCore
    571 
    572 #endif // ENABLE(INSPECTOR)
    573