DevTools: Track CSSStyleSheetHeaders in the front-end real time

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 36 matching lines @@
 #include "NamedFlow.h"
 #include "NamedFlowCollection.h"
 #include "Node.h"
 #include "NodeList.h"
 #include "RenderRegion.h"
 #include "SVGStyleElement.h"
 #include "StylePropertySet.h"
 #include "StylePropertyShorthand.h"
 #include "StyleResolver.h"
 #include "StyleRule.h"
+#include "StyleSheet.h"
 #include "StyleSheetList.h"
 
 #include <wtf/CurrentTime.h>
 #include <wtf/HashSet.h>
 #include <wtf/Vector.h>
 #include <wtf/text/CString.h>
 #include <wtf/text/StringConcatenate.h>
 
 namespace CSSAgentState {
 static const char cssAgentEnabled[] = "cssAgentEnabled";
@@ skipping 57 matching lines @@
 private:
 
     // Key is "selector?url:line".
     typedef HashMap<String, RuleMatchingStats> RuleMatchingStatsMap;
 
     double m_totalMatchingTimeMs;
     RuleMatchingStatsMap m_ruleMatchingStats;
     RuleMatchData m_currentMatchData;
 };
 
+class StyleSheetVisitor {
+public:
+    StyleSheetVisitor(CSSStyleSheet* styleSheet)
+        : m_styleSheet(styleSheet) { }
+    virtual ~StyleSheetVisitor() { }
+    void run();
+    virtual void visit(CSSStyleSheet*) = 0;
+
+private:
+    void run(CSSStyleSheet*);
+    CSSStyleSheet* m_styleSheet;
+};
+
+void StyleSheetVisitor::run()
+{
+    run(m_styleSheet);
+}
+
+void StyleSheetVisitor::run(CSSStyleSheet* styleSheet)
+{
+    visit(styleSheet);
+    for (unsigned i = 0, size = styleSheet->length(); i < size; ++i) {
+        CSSRule* rule = styleSheet->item(i);
+        if (rule->type() == CSSRule::IMPORT_RULE) {
+            CSSStyleSheet* importedStyleSheet = static_cast<CSSImportRule*>(rule)->styleSheet();
+            if (importedStyleSheet)
+                run(importedStyleSheet);
+        }
+    }
+}
+
+class StyleSheetAppender : public StyleSheetVisitor {
+public:
+    StyleSheetAppender(CSSStyleSheet* styleSheet, Vector<CSSStyleSheet*>& result)
+        : StyleSheetVisitor(styleSheet)
+        , m_result(result) { }
+
+private:
+    virtual void visit(CSSStyleSheet* styleSheet) OVERRIDE
+    {
+        m_result.append(styleSheet);
+    }
+
+    Vector<CSSStyleSheet*>& m_result;
+};
+
+class StyleSheetBinder : public StyleSheetVisitor {
+public:
+    StyleSheetBinder(InspectorCSSAgent* agent, CSSStyleSheet* styleSheet)
+        : StyleSheetVisitor(styleSheet)
+        , m_agent(agent) { }
+
+private:
+    virtual void visit(CSSStyleSheet* styleSheet) OVERRIDE
+    {
+        if (!m_agent->m_cssStyleSheetToInspectorStyleSheet.contains(styleSheet))
+            m_agent->m_frontend->styleSheetAdded(m_agent->bindStyleSheet(static_cast<CSSStyleSheet*>(styleSheet))->buildObjectForStyleSheetInfo());
+    }
+
+    InspectorCSSAgent* m_agent;
+};
+
 
 static unsigned computePseudoClassMask(InspectorArray* pseudoClassArray)
 {
     DEFINE_STATIC_LOCAL(String, active, (ASCIILiteral("active")));
     DEFINE_STATIC_LOCAL(String, hover, (ASCIILiteral("hover")));
     DEFINE_STATIC_LOCAL(String, focus, (ASCIILiteral("focus")));
     DEFINE_STATIC_LOCAL(String, visited, (ASCIILiteral("visited")));
     if (!pseudoClassArray || !pseudoClassArray->length())
         return PseudoNone;
 
@@ skipping 427 matching lines @@
     if (rule->type() != CSSRule::STYLE_RULE)
         return 0;
     return static_cast<CSSStyleRule*>(rule);
 }
 
 InspectorCSSAgent::InspectorCSSAgent(InstrumentingAgents* instrumentingAgents, InspectorCompositeState* state, InspectorDOMAgent* domAgent)
     : InspectorBaseAgent<InspectorCSSAgent>("CSS", instrumentingAgents, state)
     , m_frontend(0)
     , m_domAgent(domAgent)
     , m_lastStyleSheetId(1)
+    , m_creatingViaInspectorStyleSheet(false)
 {
     m_domAgent->setDOMListener(this);
 }
 
 InspectorCSSAgent::~InspectorCSSAgent()
 {
     ASSERT(!m_domAgent);
     reset();
 }
 
 void InspectorCSSAgent::setFrontend(InspectorFrontend* frontend)
 {
     ASSERT(!m_frontend);
     m_frontend = frontend->css();
 }
 
 void InspectorCSSAgent::clearFrontend()
 {
     ASSERT(m_frontend);
     m_frontend = 0;
     resetNonPersistentData();
-    String errorString;
-    stopSelectorProfilerImpl(&errorString, false);
+    stopSelectorProfilerImpl(0, false);
 }
 
 void InspectorCSSAgent::discardAgent()
 {
     m_domAgent->setDOMListener(0);
     m_domAgent = 0;
 }
 
 void InspectorCSSAgent::restore()
 {
@@ skipping 21 matching lines @@
     m_namedFlowCollectionsRequested.clear();
     if (m_updateRegionLayoutTask)
         m_updateRegionLayoutTask->reset();
     resetPseudoStates();
 }
 
 void InspectorCSSAgent::enable(ErrorString*)
 {
     m_state->setBoolean(CSSAgentState::cssAgentEnabled, true);
     m_instrumentingAgents->setInspectorCSSAgent(this);
+
+    RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader> > styleInfos = TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader>::create();
+    Vector<InspectorStyleSheet*> styleSheets;
+    collectAllStyleSheets(styleSheets);
+    for (size_t i = 0; i < styleSheets.size(); ++i)
+        m_frontend->styleSheetAdded(styleSheets.at(i)->buildObjectForStyleSheetInfo());
 }
 
 void InspectorCSSAgent::disable(ErrorString*)
 {
     m_instrumentingAgents->setInspectorCSSAgent(0);
     m_state->setBoolean(CSSAgentState::cssAgentEnabled, false);
 }
 
 void InspectorCSSAgent::mediaQueryResultChanged()
 {
@@ skipping 38 matching lines @@
 {
     if (namedFlow->flowState() == NamedFlow::FlowStateNull)
         return;
 
     ErrorString errorString;
     RefPtr<NamedFlow> protector(namedFlow);
 
     m_frontend->regionLayoutUpdated(buildObjectForNamedFlow(&errorString, namedFlow, documentNodeId));
 }
 
+void InspectorCSSAgent::activeStyleSheetsUpdated(const Vector<RefPtr<StyleSheet> >& newSheets)
+{
+    HashSet<CSSStyleSheet*> removedSheets;
+    for (CSSStyleSheetToInspectorStyleSheet::iterator it = m_cssStyleSheetToInspectorStyleSheet.begin(); it != m_cssStyleSheetToInspectorStyleSheet.end(); ++it) {
+        if (it->value->canBind())
+            removedSheets.add(it->key);
+    }
+
+    Vector<CSSStyleSheet*> newSheetsVector;
+    for (size_t i = 0, size = newSheets.size(); i < size; ++i) {
+        StyleSheet* newSheet = newSheets.at(i).get();
+        if (newSheet->isCSSStyleSheet()) {
+            StyleSheetAppender appender(static_cast<CSSStyleSheet*>(newSheet), newSheetsVector);
+            appender.run();
+        }
+    }
+
+    HashSet<CSSStyleSheet*> addedSheets;
+    for (size_t i = 0; i < newSheetsVector.size(); ++i) {
+        CSSStyleSheet* newCSSSheet = newSheetsVector.at(i);
+        if (removedSheets.contains(newCSSSheet))
+            removedSheets.remove(newCSSSheet);
+        else
+            addedSheets.add(newCSSSheet);
+    }
+
+    RefPtr<TypeBuilder::Array<TypeBuilder::CSS::StyleSheetId> > removedIds = TypeBuilder::Array<TypeBuilder::CSS::StyleSheetId>::create();
+    for (HashSet<CSSStyleSheet*>::iterator it = removedSheets.begin(); it != removedSheets.end(); ++it) {
+        RefPtr<InspectorStyleSheet> inspectorStyleSheet = m_cssStyleSheetToInspectorStyleSheet.get(*it);
+        ASSERT(inspectorStyleSheet);
+        unbindStyleSheetRecursively(inspectorStyleSheet.get());
+    }
+    RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader> > addedHeaders = TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader>::create();
+    for (HashSet<CSSStyleSheet*>::iterator it = addedSheets.begin(); it != addedSheets.end(); ++it)
+        bindStyleSheetRecursively(static_cast<CSSStyleSheet*>(*it));
+}
+
 bool InspectorCSSAgent::forcePseudoState(Element* element, CSSSelector::PseudoType pseudoType)
 {
     if (m_nodeIdToForcedPseudoState.isEmpty())
         return false;
 
     int nodeId = m_domAgent->boundNodeId(element);
     if (!nodeId)
         return false;
 
     NodeIdToForcedPseudoState::iterator it = m_nodeIdToForcedPseudoState.find(nodeId);
@@ skipping 87 matching lines @@
         return;
 
     RefPtr<CSSComputedStyleDeclaration> computedStyleInfo = CSSComputedStyleDeclaration::create(element, true);
     RefPtr<InspectorStyle> inspectorStyle = InspectorStyle::create(InspectorCSSId(), computedStyleInfo, 0);
     style = inspectorStyle->buildArrayForComputedStyle();
 }
 
 void InspectorCSSAgent::getAllStyleSheets(ErrorString*, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader> >& styleInfos)
 {
     styleInfos = TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader>::create();
-    Vector<Document*> documents = m_domAgent->documents();
-    for (Vector<Document*>::iterator it = documents.begin(); it != documents.end(); ++it) {
-        StyleSheetList* list = (*it)->styleSheets();
-        for (unsigned i = 0; i < list->length(); ++i) {
-            StyleSheet* styleSheet = list->item(i);
-            if (styleSheet->isCSSStyleSheet())
-                collectStyleSheets(static_cast<CSSStyleSheet*>(styleSheet), styleInfos.get());
-        }
-    }
+    Vector<InspectorStyleSheet*> styleSheets;
+    collectAllStyleSheets(styleSheets);
+    for (size_t i = 0; i < styleSheets.size(); ++i)
+        styleInfos->addItem(styleSheets.at(i)->buildObjectForStyleSheetInfo());
 }
 
 void InspectorCSSAgent::getStyleSheet(ErrorString* errorString, const String& styleSheetId, RefPtr<TypeBuilder::CSS::CSSStyleSheetBody>& styleSheetObject)
 {
     InspectorStyleSheet* inspectorStyleSheet = assertStyleSheetForId(errorString, styleSheetId);
     if (!inspectorStyleSheet)
         return;
 
     styleSheetObject = inspectorStyleSheet->buildObjectForStyleSheet();
 }
@@ skipping 252 matching lines @@
 
 int InspectorCSSAgent::documentNodeWithRequestedFlowsId(Document* document)
 {
     int documentNodeId = m_domAgent->boundNodeId(document);
     if (!documentNodeId || !m_namedFlowCollectionsRequested.contains(documentNodeId))
         return 0;
 
     return documentNodeId;
 }
 
-void InspectorCSSAgent::collectStyleSheets(CSSStyleSheet* styleSheet, TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader>* result)
+void InspectorCSSAgent::collectAllStyleSheets(Vector<InspectorStyleSheet*>& result)
+{
+    Vector<Document*> documents = m_domAgent->documents();
+    for (Vector<Document*>::iterator it = documents.begin(); it != documents.end(); ++it) {
+        StyleSheetList* list = (*it)->styleSheets();
+        for (unsigned i = 0; i < list->length(); ++i) {
+            StyleSheet* styleSheet = list->item(i);
+            if (styleSheet->isCSSStyleSheet())
+                collectStyleSheets(static_cast<CSSStyleSheet*>(styleSheet), result);
+        }
+    }
+}
+
+void InspectorCSSAgent::collectStyleSheets(CSSStyleSheet* styleSheet, Vector<InspectorStyleSheet*>& result)
 {
     InspectorStyleSheet* inspectorStyleSheet = bindStyleSheet(static_cast<CSSStyleSheet*>(styleSheet));
-    result->addItem(inspectorStyleSheet->buildObjectForStyleSheetInfo());
+    result.append(inspectorStyleSheet);
     for (unsigned i = 0, size = styleSheet->length(); i < size; ++i) {
         CSSRule* rule = styleSheet->item(i);
         if (rule->type() == CSSRule::IMPORT_RULE) {
             CSSStyleSheet* importedStyleSheet = static_cast<CSSImportRule*>(rule)->styleSheet();
             if (importedStyleSheet)
                 collectStyleSheets(importedStyleSheet, result);
         }
     }
 }
 
+void InspectorCSSAgent::bindStyleSheetRecursively(CSSStyleSheet* styleSheet)
+{
+    StyleSheetBinder binder(this, styleSheet);
+    binder.run();
+}
+
 InspectorStyleSheet* InspectorCSSAgent::bindStyleSheet(CSSStyleSheet* styleSheet)
 {
     RefPtr<InspectorStyleSheet> inspectorStyleSheet = m_cssStyleSheetToInspectorStyleSheet.get(styleSheet);
     if (!inspectorStyleSheet) {
         String id = String::number(m_lastStyleSheetId++);
         Document* document = styleSheet->ownerDocument();
         inspectorStyleSheet = InspectorStyleSheet::create(m_domAgent->pageAgent(), id, styleSheet, detectOrigin(styleSheet, document), InspectorDOMAgent::documentURLString(document), this);
         m_idToInspectorStyleSheet.set(id, inspectorStyleSheet);
         m_cssStyleSheetToInspectorStyleSheet.set(styleSheet, inspectorStyleSheet);
+        if (m_creatingViaInspectorStyleSheet)
+            m_documentToInspectorStyleSheet.add(document, inspectorStyleSheet);
     }
     return inspectorStyleSheet.get();
 }
 
+String InspectorCSSAgent::unbindStyleSheet(InspectorStyleSheet* inspectorStyleSheet)
+{
+    String id = inspectorStyleSheet->id();
+    m_idToInspectorStyleSheet.remove(id);
+    if (inspectorStyleSheet->pageStyleSheet())
+        m_cssStyleSheetToInspectorStyleSheet.remove(inspectorStyleSheet->pageStyleSheet());
+    return id;
+}
+
+void InspectorCSSAgent::unbindStyleSheetRecursively(InspectorStyleSheet* inspectorStyleSheet)
+{
+    if (!inspectorStyleSheet)
+        return;
+    CSSStyleSheet* styleSheet = inspectorStyleSheet->pageStyleSheet();
+    if (!styleSheet)
+        return;
+    for (unsigned i = 0, size = styleSheet->length(); i < size; ++i) {
+        CSSRule* rule = styleSheet->item(i);
+        if (rule->type() == CSSRule::IMPORT_RULE) {
+            CSSStyleSheet* importedStyleSheet = static_cast<CSSImportRule*>(rule)->styleSheet();
+            if (importedStyleSheet) {
+                RefPtr<InspectorStyleSheet> importedChild = m_cssStyleSheetToInspectorStyleSheet.get(importedStyleSheet);
+                unbindStyleSheetRecursively(importedChild.get());
+            }
+        }
+    }
+    if (m_idToInspectorStyleSheet.contains(inspectorStyleSheet->id()))
+        m_frontend->styleSheetRemoved(unbindStyleSheet(inspectorStyleSheet));
+}
+
 InspectorStyleSheet* InspectorCSSAgent::viaInspectorStyleSheet(Document* document, bool createIfAbsent)
 {
     if (!document) {
         ASSERT(!createIfAbsent);
         return 0;
     }
 
     if (!document->isHTMLDocument() && !document->isSVGDocument())
         return 0;
 
     RefPtr<InspectorStyleSheet> inspectorStyleSheet = m_documentToInspectorStyleSheet.get(document);
     if (inspectorStyleSheet || !createIfAbsent)
         return inspectorStyleSheet.get();
 
     ExceptionCode ec = 0;
     RefPtr<Element> styleElement = document->createElement("style", ec);
     if (!ec)
         styleElement->setAttribute("type", "text/css", ec);
     if (!ec) {
         ContainerNode* targetNode;
         // HEAD is absent in ImageDocuments, for example.
         if (document->head())
             targetNode = document->head();
         else if (document->body())
             targetNode = document->body();
         else
             return 0;
 
         InlineStyleOverrideScope overrideScope(document);
+        m_creatingViaInspectorStyleSheet = true;
         targetNode->appendChild(styleElement, ec);
+        // At this point the added stylesheet will get bound through the updateActiveStyleSheets() invocation.
+        // We just need to pick the respective InspectorStyleSheet from m_documentToInspectorStyleSheet.
+        m_creatingViaInspectorStyleSheet = false;
     }
     if (ec)
         return 0;
 
-    CSSStyleSheet* cssStyleSheet = 0;
-    if (styleElement->isHTMLElement())
-        cssStyleSheet = static_cast<HTMLStyleElement*>(styleElement.get())->sheet();
-#if ENABLE(SVG)
-    else if (styleElement->isSVGElement())
-        cssStyleSheet = static_cast<SVGStyleElement*>(styleElement.get())->sheet();
-#endif
-
-    if (!cssStyleSheet)
-        return 0;
-
-    String id = String::number(m_lastStyleSheetId++);
-    inspectorStyleSheet = InspectorStyleSheet::create(m_domAgent->pageAgent(), id, cssStyleSheet, TypeBuilder::CSS::StyleSheetOrigin::Inspector, InspectorDOMAgent::documentURLString(document), this);
-    m_idToInspectorStyleSheet.set(id, inspectorStyleSheet);
-    m_cssStyleSheetToInspectorStyleSheet.set(cssStyleSheet, inspectorStyleSheet);
-    m_documentToInspectorStyleSheet.set(document, inspectorStyleSheet);
-    return inspectorStyleSheet.get();
+    return m_documentToInspectorStyleSheet.get(document).get();
 }
 
 InspectorStyleSheet* InspectorCSSAgent::assertStyleSheetForId(ErrorString* errorString, const String& styleSheetId)
 {
     IdToInspectorStyleSheet::iterator it = m_idToInspectorStyleSheet.find(styleSheetId);
     if (it == m_idToInspectorStyleSheet.end()) {
         *errorString = "No style sheet with given id found";
         return 0;
     }
     return it->value.get();
 }
 
 TypeBuilder::CSS::StyleSheetOrigin::Enum InspectorCSSAgent::detectOrigin(CSSStyleSheet* pageStyleSheet, Document* ownerDocument)
 {
+    if (m_creatingViaInspectorStyleSheet)
+        return TypeBuilder::CSS::StyleSheetOrigin::Inspector;
+
     TypeBuilder::CSS::StyleSheetOrigin::Enum origin = TypeBuilder::CSS::StyleSheetOrigin::Regular;
     if (pageStyleSheet && !pageStyleSheet->ownerNode() && pageStyleSheet->href().isEmpty())
         origin = TypeBuilder::CSS::StyleSheetOrigin::User_agent;
     else if (pageStyleSheet && pageStyleSheet->ownerNode() && pageStyleSheet->ownerNode()->nodeName() == "#document")
         origin = TypeBuilder::CSS::StyleSheetOrigin::User;
     else {
         InspectorStyleSheet* viaInspectorStyleSheetForOwner = viaInspectorStyleSheet(ownerDocument, false);
         if (viaInspectorStyleSheetForOwner && pageStyleSheet == viaInspectorStyleSheetForOwner->pageStyleSheet())
             origin = TypeBuilder::CSS::StyleSheetOrigin::Inspector;
     }
     return origin;
 }
 
 PassRefPtr<TypeBuilder::CSS::CSSRule> InspectorCSSAgent::buildObjectForRule(CSSStyleRule* rule, StyleResolver* styleResolver)
 {
     if (!rule)
         return 0;
 
     // CSSRules returned by StyleResolver::styleRulesForElement lack parent pointers since that infomation is not cheaply available.
     // Since the inspector wants to walk the parent chain, we construct the full wrappers here.
     // FIXME: This could be factored better. StyleResolver::styleRulesForElement should return a StyleRule vector, not a CSSRuleList.
     if (!rule->parentStyleSheet()) {
         rule = styleResolver->inspectorCSSOMWrappers().getWrapperForRuleInSheets(rule->styleRule(), styleResolver->document()->styleSheetCollection());
         if (!rule)
             return 0;
     }
-    InspectorStyleSheet* inspectorStyleSheet = bindStyleSheet(rule->parentStyleSheet());
-    return inspectorStyleSheet ? inspectorStyleSheet->buildObjectForRule(rule) : 0;
+    return bindStyleSheet(rule->parentStyleSheet())->buildObjectForRule(rule);
 }
 
 PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > InspectorCSSAgent::buildArrayForRuleList(CSSRuleList* ruleList, StyleResolver* styleResolver)
 {
     RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > result = TypeBuilder::Array<TypeBuilder::CSS::CSSRule>::create();
     if (!ruleList)
         return result.release();
 
     for (unsigned i = 0, size = ruleList->length(); i < size; ++i) {
         CSSStyleRule* rule = asCSSStyleRule(ruleList->item(i));
@@ skipping 152 matching lines @@
             documentsToChange.add(element->ownerDocument());
     }
 
     m_nodeIdToForcedPseudoState.clear();
     for (HashSet<Document*>::iterator it = documentsToChange.begin(), end = documentsToChange.end(); it != end; ++it)
         (*it)->styleResolverChanged(RecalcStyleImmediately);
 }
 
 } // namespace WebCore