DevTools: Load document (html) content from disk cache in page agent enabling.

Source/core/inspector/InspectorController.cpp

 /*
  * Copyright (C) 2011 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 16 matching lines @@
  * (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/InspectorController.h"
 
 #include "InspectorBackendDispatcher.h"
 #include "InspectorFrontend.h"
 #include "bindings/v8/DOMWrapperWorld.h"
+#include "core/html/VoidCallback.h"
 #include "core/inspector/IdentifiersFactory.h"
 #include "core/inspector/InjectedScriptHost.h"
 #include "core/inspector/InjectedScriptManager.h"
 #include "core/inspector/InspectorApplicationCacheAgent.h"
 #include "core/inspector/InspectorCSSAgent.h"
 #include "core/inspector/InspectorCanvasAgent.h"
 #include "core/inspector/InspectorClient.h"
 #include "core/inspector/InspectorDOMAgent.h"
 #include "core/inspector/InspectorDOMDebuggerAgent.h"
 #include "core/inspector/InspectorDOMStorageAgent.h"
 #include "core/inspector/InspectorDebuggerAgent.h"
 #include "core/inspector/InspectorFrontendClient.h"
 #include "core/inspector/InspectorHeapProfilerAgent.h"
 #include "core/inspector/InspectorInputAgent.h"
 #include "core/inspector/InspectorInspectorAgent.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorLayerTreeAgent.h"
 #include "core/inspector/InspectorMemoryAgent.h"
 #include "core/inspector/InspectorOverlay.h"
 #include "core/inspector/InspectorPageAgent.h"
 #include "core/inspector/InspectorProfilerAgent.h"
 #include "core/inspector/InspectorResourceAgent.h"
+#include "core/inspector/InspectorResourceContentLoader.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InspectorTimelineAgent.h"
 #include "core/inspector/InspectorTracingAgent.h"
 #include "core/inspector/InspectorWorkerAgent.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/inspector/PageConsoleAgent.h"
 #include "core/inspector/PageDebuggerAgent.h"
 #include "core/inspector/PageRuntimeAgent.h"
 #include "core/page/Page.h"
 #include "core/rendering/RenderLayer.h"
 #include "platform/PlatformMouseEvent.h"
 
 namespace WebCore {
 
+class InspectorController::InspectorResourceContentLoaderCallback FINAL : public VoidCallback {
+public:
+    InspectorResourceContentLoaderCallback(InspectorController*);
+    virtual void handleEvent() OVERRIDE;
+
+private:
+    InspectorController* m_inspectorController;
+};
+
+InspectorController::InspectorResourceContentLoaderCallback::InspectorResourceContentLoaderCallback(InspectorController* inspectorController)
+    : m_inspectorController(inspectorController)
+{
+}
+
+void InspectorController::InspectorResourceContentLoaderCallback::handleEvent()
+{
+    m_inspectorController->resourcesContentLoaded();
+}
+
 InspectorController::InspectorController(Page* page, InspectorClient* inspectorClient)
     : m_instrumentingAgents(InstrumentingAgents::create())
     , m_injectedScriptManager(InjectedScriptManager::createForPage())
     , m_state(adoptPtr(new InspectorCompositeState(inspectorClient)))
     , m_overlay(InspectorOverlay::create(page, inspectorClient))
     , m_layerTreeAgent(0)
     , m_page(page)
     , m_inspectorClient(inspectorClient)
     , m_agents(m_instrumentingAgents.get(), m_state.get())
     , m_isUnderTest(false)
@@ skipping 59 matching lines @@
 
 void InspectorController::initializeDeferredAgents()
 {
     if (m_deferredAgentsInitialized)
         return;
     m_deferredAgentsInitialized = true;
 
     InjectedScriptManager* injectedScriptManager = m_injectedScriptManager.get();
     InspectorOverlay* overlay = m_overlay.get();
 
-    OwnPtr<InspectorResourceAgent> resourceAgentPtr(InspectorResourceAgent::create(m_pageAgent));
-    InspectorResourceAgent* resourceAgent = resourceAgentPtr.get();
-    m_agents.append(resourceAgentPtr.release());
-
-    m_agents.append(InspectorCSSAgent::create(m_domAgent, m_pageAgent, resourceAgent));
+    m_agents.append(InspectorCSSAgent::create(m_domAgent, m_pageAgent));
 
     m_agents.append(InspectorDOMStorageAgent::create(m_pageAgent));
 
     m_agents.append(InspectorMemoryAgent::create());
 
     m_agents.append(InspectorApplicationCacheAgent::create(m_pageAgent));
 
+    m_agents.append(InspectorResourceAgent::create(m_pageAgent));
+
     PageScriptDebugServer* pageScriptDebugServer = &PageScriptDebugServer::shared();
 
     OwnPtr<InspectorDebuggerAgent> debuggerAgentPtr(PageDebuggerAgent::create(pageScriptDebugServer, m_pageAgent, injectedScriptManager, overlay));
     InspectorDebuggerAgent* debuggerAgent = debuggerAgentPtr.get();
     m_agents.append(debuggerAgentPtr.release());
 
     m_agents.append(InspectorDOMDebuggerAgent::create(m_domAgent, debuggerAgent));
 
     m_agents.append(InspectorProfilerAgent::create(injectedScriptManager, overlay));
 
@@ skipping 26 matching lines @@
 }
 
 void InspectorController::didClearDocumentOfWindowObject(LocalFrame* frame)
 {
     // If the page is supposed to serve as InspectorFrontend notify inspector frontend
     // client that it's cleared so that the client can expose inspector bindings.
     if (m_inspectorFrontendClient && frame == m_page->mainFrame())
         m_inspectorFrontendClient->windowObjectCleared();
 }
 
-void InspectorController::connectFrontend(InspectorFrontendChannel* frontendChannel)
+void InspectorController::connectFrontend(InspectorFrontendChannel* frontendChannel, bool isReusing)
 {
     ASSERT(frontendChannel);
 
     initializeDeferredAgents();
 
     m_inspectorFrontend = adoptPtr(new InspectorFrontend(frontendChannel));
     // We can reconnect to existing front-end -> unmute state.
     m_state->unmute();
 
     m_agents.setFrontend(m_inspectorFrontend.get());
 
     InspectorInstrumentation::registerInstrumentingAgents(m_instrumentingAgents.get());
     InspectorInstrumentation::frontendCreated();
 
     ASSERT(m_inspectorClient);
     m_inspectorBackendDispatcher = InspectorBackendDispatcher::create(frontendChannel);
 
     m_agents.registerInDispatcher(m_inspectorBackendDispatcher.get());
+
+    if (!isReusing)
+        m_inspectorResourceContentLoader = adoptPtr(new InspectorResourceContentLoader(m_page, adoptPtr(new InspectorResourceContentLoaderCallback(this))));
+}
+
+void InspectorController::resourcesContentLoaded()
+{
+    for (Vector<String>::const_iterator it = m_messages.begin(); it != m_messages.end(); ++it)

[pfeldman, 2014/05/20 19:50:49]

You want to iterate a copy just in case.

+        dispatchMessageFromFrontend(*it);
+    m_messages.clear();
 }
 
 void InspectorController::disconnectFrontend()
 {
     if (!m_inspectorFrontend)
         return;
+    m_inspectorResourceContentLoader.clear();
     m_inspectorBackendDispatcher->clearFrontend();
     m_inspectorBackendDispatcher.clear();
 
     // Destroying agents would change the state, but we don't want that.
     // Pre-disconnect state will be used to restore inspector agents.
     m_state->mute();
 
     m_agents.clearFrontend();
 
     m_inspectorFrontend.clear();
 
     // relese overlay page resources
     m_overlay->freePage();
     InspectorInstrumentation::frontendDeleted();
     InspectorInstrumentation::unregisterInstrumentingAgents(m_instrumentingAgents.get());
 }
 
 void InspectorController::reconnectFrontend()
 {
     if (!m_inspectorFrontend)
         return;
     InspectorFrontendChannel* frontendChannel = m_inspectorFrontend->channel();
     disconnectFrontend();
     connectFrontend(frontendChannel);
 }
 
 void InspectorController::reuseFrontend(InspectorFrontendChannel* frontendChannel, const String& inspectorStateCookie)
 {
     ASSERT(!m_inspectorFrontend);
-    connectFrontend(frontendChannel);
+    connectFrontend(frontendChannel, true);
     m_state->loadFromCookie(inspectorStateCookie);
     m_agents.restore();
 }
 
 void InspectorController::setProcessId(long processId)
 {
     IdentifiersFactory::setProcessId(processId);
 }
 
 void InspectorController::setLayerTreeId(int id)
@@ skipping 46 matching lines @@
 }
 
 void InspectorController::setInjectedScriptForOrigin(const String& origin, const String& source)
 {
     if (InspectorInspectorAgent* inspectorAgent = m_instrumentingAgents->inspectorInspectorAgent())
         inspectorAgent->setInjectedScriptForOrigin(origin, source);
 }
 
 void InspectorController::dispatchMessageFromFrontend(const String& message)
 {
+    if (m_inspectorResourceContentLoader && !m_inspectorResourceContentLoader->hasFinished()) {
+        m_messages.append(message);
+        return;
+    }
+
     if (m_inspectorBackendDispatcher)
         m_inspectorBackendDispatcher->dispatch(message);
 }
 
 bool InspectorController::handleGestureEvent(LocalFrame* frame, const PlatformGestureEvent& event)
 {
     // Overlay should not consume events.
     m_overlay->handleGestureEvent(event);
     if (InspectorDOMAgent* domAgent = m_instrumentingAgents->inspectorDOMAgent())
         return domAgent->handleGestureEvent(frame, event);
@@ skipping 77 matching lines @@
         domDebuggerAgent->didProcessTask();
 }
 
 void InspectorController::flushPendingFrontendMessages()
 {
     m_agents.flushPendingFrontendMessages();
 }
 
 void InspectorController::didCommitLoadForMainFrame()
 {
+    m_inspectorResourceContentLoader.clear();
     Vector<InspectorAgent*> agents = m_moduleAgents;
     for (size_t i = 0; i < agents.size(); i++)
         agents[i]->didCommitLoadForMainFrame();
 }
 
 void InspectorController::didBeginFrame(int frameId)
 {
     if (InspectorTimelineAgent* timelineAgent = m_instrumentingAgents->inspectorTimelineAgent())
         timelineAgent->didBeginFrame(frameId);
     if (InspectorCanvasAgent* canvasAgent = m_instrumentingAgents->inspectorCanvasAgent())
@@ skipping 36 matching lines @@
         m_layerTreeAgent->willAddPageOverlay(layer);
 }
 
 void InspectorController::didRemovePageOverlay(const GraphicsLayer* layer)
 {
     if (m_layerTreeAgent)
         m_layerTreeAgent->didRemovePageOverlay(layer);
 }
 
 } // namespace WebCore