Revert 176213 "DevTools: Load document (html) content from disk ..."

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
  *     documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/inspector/InspectorCSSAgent.h"
 
 #include "CSSPropertyNames.h"
+#include "FetchInitiatorTypeNames.h"
 #include "InspectorTypeBuilder.h"
 #include "StylePropertyShorthand.h"
 #include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/ExceptionStatePlaceholder.h"
 #include "core/css/CSSComputedStyleDeclaration.h"
 #include "core/css/CSSDefaultStyleSheets.h"
 #include "core/css/CSSImportRule.h"
 #include "core/css/CSSMediaRule.h"
 #include "core/css/CSSRule.h"
 #include "core/css/CSSRuleList.h"
 #include "core/css/CSSStyleRule.h"
 #include "core/css/CSSStyleSheet.h"
 #include "core/css/MediaList.h"
 #include "core/css/MediaQuery.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/StyleSheet.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/StyleSheetList.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Node.h"
 #include "core/dom/NodeList.h"
+#include "core/fetch/CSSStyleSheetResource.h"
+#include "core/fetch/ResourceClient.h"
+#include "core/fetch/ResourceFetcher.h"
+#include "core/fetch/StyleSheetResourceClient.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLHeadElement.h"
-#include "core/html/VoidCallback.h"
 #include "core/inspector/InspectorHistory.h"
 #include "core/inspector/InspectorPageAgent.h"
 #include "core/inspector/InspectorResourceAgent.h"
-#include "core/inspector/InspectorResourceContentLoader.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/Page.h"
 #include "core/rendering/InlineTextBox.h"
 #include "core/rendering/RenderObject.h"
 #include "core/rendering/RenderText.h"
 #include "core/rendering/RenderTextFragment.h"
 #include "platform/fonts/Font.h"
 #include "platform/fonts/GlyphBuffer.h"
@@ skipping 50 matching lines @@
 
 class InspectorCSSAgent::StyleSheetAction : public InspectorHistory::Action {
     WTF_MAKE_NONCOPYABLE(StyleSheetAction);
 public:
     StyleSheetAction(const String& name)
         : InspectorHistory::Action(name)
     {
     }
 };
 
-class InspectorCSSAgent::InspectorResourceContentLoaderCallback FINAL : public VoidCallback {
+class InspectorCSSAgent::EnableResourceClient FINAL : public StyleSheetResourceClient {
 public:
-    InspectorResourceContentLoaderCallback(InspectorCSSAgent*, PassRefPtr<EnableCallback>);
-    virtual void handleEvent() OVERRIDE;
+    EnableResourceClient(InspectorCSSAgent*, const Vector<InspectorStyleSheet*>&, PassRefPtr<EnableCallback>);
+
+    virtual void setCSSStyleSheet(const String&, const KURL&, const String&, const CSSStyleSheetResource*) OVERRIDE;
 
 private:
+    RefPtr<EnableCallback> m_callback;
     InspectorCSSAgent* m_cssAgent;
-    RefPtr<EnableCallback> m_callback;
+    int m_pendingResources;
+    Vector<InspectorStyleSheet*> m_styleSheets;
 };
 
-InspectorCSSAgent::InspectorResourceContentLoaderCallback::InspectorResourceContentLoaderCallback(InspectorCSSAgent* cssAgent, PassRefPtr<EnableCallback> callback)
-    : m_cssAgent(cssAgent)
-    , m_callback(callback)
+InspectorCSSAgent::EnableResourceClient::EnableResourceClient(InspectorCSSAgent* cssAgent, const Vector<InspectorStyleSheet*>& styleSheets, PassRefPtr<EnableCallback> callback)
+    : m_callback(callback)
+    , m_cssAgent(cssAgent)
+    , m_pendingResources(styleSheets.size())
+    , m_styleSheets(styleSheets)
 {
+    for (size_t i = 0; i < styleSheets.size(); ++i) {
+        InspectorStyleSheet* styleSheet = styleSheets.at(i);
+        Document* document = styleSheet->ownerDocument();
+        FetchRequest request(ResourceRequest(styleSheet->finalURL()), FetchInitiatorTypeNames::internal);
+        ResourcePtr<Resource> resource = document->fetcher()->fetchCSSStyleSheet(request);
+        resource->addClient(this);
+    }
 }
 
-void InspectorCSSAgent::InspectorResourceContentLoaderCallback::handleEvent()
+void InspectorCSSAgent::EnableResourceClient::setCSSStyleSheet(const String&, const KURL& url, const String&, const CSSStyleSheetResource* resource)
 {
-    // enable always succeeds.
-    if (!m_callback->isActive())
+    const_cast<CSSStyleSheetResource*>(resource)->removeClient(this);
+    --m_pendingResources;
+    if (m_pendingResources)
         return;
 
-    m_cssAgent->wasEnabled();
-    m_callback->sendSuccess();
+    // enable always succeeds.
+    if (m_callback->isActive())
+        m_cssAgent->wasEnabled(m_callback.release());
+    delete this;
 }
 
 class InspectorCSSAgent::SetStyleSheetTextAction FINAL : public InspectorCSSAgent::StyleSheetAction {
     WTF_MAKE_NONCOPYABLE(SetStyleSheetTextAction);
 public:
     SetStyleSheetTextAction(InspectorStyleSheetBase* styleSheet, const String& text)
         : InspectorCSSAgent::StyleSheetAction("SetStyleSheetText")
         , m_styleSheet(styleSheet)
         , m_text(text)
     {
@@ skipping 214 matching lines @@
 
 void InspectorCSSAgent::discardAgent()
 {
     m_domAgent->setDOMListener(0);
     m_domAgent = 0;
 }
 
 void InspectorCSSAgent::restore()
 {
     if (m_state->getBoolean(CSSAgentState::cssAgentEnabled))
-        wasEnabled();
+        wasEnabled(nullptr);
 }
 
 void InspectorCSSAgent::flushPendingFrontendMessages()
 {
     if (!m_invalidatedDocuments.size())
         return;
     HashSet<Document*> invalidatedDocuments;
     m_invalidatedDocuments.swap(&invalidatedDocuments);
     for (HashSet<Document*>::iterator it = invalidatedDocuments.begin(); it != invalidatedDocuments.end(); ++it)
         updateActiveStyleSheets(*it, ExistingFrontendRefresh);
@@ skipping 12 matching lines @@
 }
 
 void InspectorCSSAgent::resetNonPersistentData()
 {
     resetPseudoStates();
 }
 
 void InspectorCSSAgent::enable(ErrorString*, PassRefPtr<EnableCallback> prpCallback)
 {
     m_state->setBoolean(CSSAgentState::cssAgentEnabled, true);
-    if (!m_pageAgent->resourceContentLoader()) {
-        wasEnabled();
-        prpCallback->sendSuccess();
+
+    Vector<InspectorStyleSheet*> styleSheets;
+    collectAllStyleSheets(styleSheets);
+
+    // Re-issue stylesheet requets for resources that are no longer in memory cache.
+    Vector<InspectorStyleSheet*> styleSheetsToFetch;
+    HashSet<String> urlsToFetch;
+    for (size_t i = 0; i < styleSheets.size(); ++i) {
+        InspectorStyleSheet* styleSheet = styleSheets.at(i);
+        String url = styleSheet->finalURL();
+        if (urlsToFetch.contains(url))
+            continue;
+        CSSStyleSheet* pageStyleSheet = styleSheet->pageStyleSheet();
+        if (pageStyleSheet->isInline() || !pageStyleSheet->contents()->loadCompleted())
+            continue;
+        Document* document = styleSheet->ownerDocument();
+        if (!document)
+            continue;
+        Resource* cachedResource = document->fetcher()->cachedResource(document->completeURL(url));
+        if (cachedResource)
+            continue;
+        urlsToFetch.add(styleSheet->finalURL());
+        styleSheetsToFetch.append(styleSheet);
+    }
+
+    if (styleSheetsToFetch.isEmpty()) {
+        wasEnabled(prpCallback);
         return;
     }
-    m_pageAgent->resourceContentLoader()->addListener(adoptPtr(new InspectorCSSAgent::InspectorResourceContentLoaderCallback(this, prpCallback)));
+    new EnableResourceClient(this, styleSheetsToFetch, prpCallback);
 }
 
-void InspectorCSSAgent::wasEnabled()
+void InspectorCSSAgent::wasEnabled(PassRefPtr<EnableCallback> callback)
 {
     if (!m_state->getBoolean(CSSAgentState::cssAgentEnabled)) {
         // We were disabled while fetching resources.
         return;
     }
 
     m_instrumentingAgents->setInspectorCSSAgent(this);
     Vector<Document*> documents = m_domAgent->documents();
     for (Vector<Document*>::iterator it = documents.begin(); it != documents.end(); ++it)
         updateActiveStyleSheets(*it, InitialFrontendLoad);
+
+    if (callback)
+        callback->sendSuccess();
 }
 
 void InspectorCSSAgent::disable(ErrorString*)
 {
     reset();
     m_instrumentingAgents->setInspectorCSSAgent(0);
     m_state->setBoolean(CSSAgentState::cssAgentEnabled, false);
 }
 
 void InspectorCSSAgent::didCommitLoadForMainFrame()
@@ skipping 46 matching lines @@
     if (styleSheetEditInProgress())
         return;
     m_invalidatedDocuments.add(document);
     if (m_creatingViaInspectorStyleSheet)
         flushPendingFrontendMessages();
 }
 
 void InspectorCSSAgent::updateActiveStyleSheets(Document* document, StyleSheetsUpdateType styleSheetsUpdateType)
 {
     Vector<CSSStyleSheet*> newSheetsVector;
-    InspectorCSSAgent::collectAllDocumentStyleSheets(document, newSheetsVector);
+    collectAllDocumentStyleSheets(document, newSheetsVector);
     setActiveStyleSheets(document, newSheetsVector, styleSheetsUpdateType);
 }
 
 void InspectorCSSAgent::setActiveStyleSheets(Document* document, const Vector<CSSStyleSheet*>& allSheetsVector, StyleSheetsUpdateType styleSheetsUpdateType)
 {
     bool isInitialFrontendLoad = styleSheetsUpdateType == InitialFrontendLoad;
 
     HashSet<CSSStyleSheet*>* documentCSSStyleSheets = m_documentToCSSStyleSheets.get(document);
     if (!documentCSSStyleSheets) {
         documentCSSStyleSheets = new HashSet<CSSStyleSheet*>();
@@ skipping 602 matching lines @@
         *errorString = "No node with given id found";
         return 0;
     }
     if (!node->isElementNode()) {
         *errorString = "Not an element node";
         return 0;
     }
     return toElement(node);
 }
 
-// static
+void InspectorCSSAgent::collectAllStyleSheets(Vector<InspectorStyleSheet*>& result)
+{
+    Vector<CSSStyleSheet*> cssStyleSheets;
+    Vector<Document*> documents = m_domAgent->documents();
+    for (Vector<Document*>::iterator it = documents.begin(); it != documents.end(); ++it)
+        collectAllDocumentStyleSheets(*it, cssStyleSheets);
+    for (Vector<CSSStyleSheet*>::iterator it = cssStyleSheets.begin(); it != cssStyleSheets.end(); ++it)
+        result.append(bindStyleSheet(*it));
+}
+
 void InspectorCSSAgent::collectAllDocumentStyleSheets(Document* document, Vector<CSSStyleSheet*>& result)
 {
     const WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> > activeStyleSheets = document->styleEngine()->activeStyleSheetsForInspector();
     for (WillBeHeapVector<RefPtrWillBeMember<CSSStyleSheet> >::const_iterator it = activeStyleSheets.begin(); it != activeStyleSheets.end(); ++it) {
         CSSStyleSheet* styleSheet = it->get();
-        InspectorCSSAgent::collectStyleSheets(styleSheet, result);
+        collectStyleSheets(styleSheet, result);
     }
 }
 
-// static
 void InspectorCSSAgent::collectStyleSheets(CSSStyleSheet* styleSheet, Vector<CSSStyleSheet*>& result)
 {
     result.append(styleSheet);
     for (unsigned i = 0, size = styleSheet->length(); i < size; ++i) {
         CSSRule* rule = styleSheet->item(i);
         if (rule->type() == CSSRule::IMPORT_RULE) {
             CSSStyleSheet* importedStyleSheet = toCSSImportRule(rule)->styleSheet();
             if (importedStyleSheet)
-                InspectorCSSAgent::collectStyleSheets(importedStyleSheet, result);
+                collectStyleSheets(importedStyleSheet, result);
         }
     }
 }
 
 InspectorStyleSheet* InspectorCSSAgent::bindStyleSheet(CSSStyleSheet* styleSheet)
 {
     RefPtr<InspectorStyleSheet> inspectorStyleSheet = m_cssStyleSheetToInspectorStyleSheet.get(styleSheet);
     if (!inspectorStyleSheet) {
         String id = String::number(m_lastStyleSheetId++);
         Document* document = styleSheet->ownerDocument();
@@ skipping 237 matching lines @@
             documentsToChange.add(element->ownerDocument());
     }
 
     m_nodeIdToForcedPseudoState.clear();
     for (HashSet<Document*>::iterator it = documentsToChange.begin(), end = documentsToChange.end(); it != end; ++it)
         (*it)->setNeedsStyleRecalc(SubtreeStyleChange);
 }
 
 } // namespace WebCore