WorkerInspectorController.cpp [plain text]
#include "config.h"
#if ENABLE(INSPECTOR) && ENABLE(WORKERS)
#include "WorkerInspectorController.h"
#include "InjectedScriptHost.h"
#include "InjectedScriptManager.h"
#include "InspectorBackendDispatcher.h"
#include "InspectorClient.h"
#include "InspectorConsoleAgent.h"
#include "InspectorFrontend.h"
#include "InspectorFrontendChannel.h"
#include "InspectorHeapProfilerAgent.h"
#include "InspectorProfilerAgent.h"
#include "InspectorState.h"
#include "InspectorStateClient.h"
#include "InspectorTimelineAgent.h"
#include "InstrumentingAgents.h"
#include "WorkerConsoleAgent.h"
#include "WorkerContext.h"
#include "WorkerDebuggerAgent.h"
#include "WorkerReportingProxy.h"
#include "WorkerRuntimeAgent.h"
#include "WorkerThread.h"
#include <wtf/PassOwnPtr.h>
namespace WebCore {
namespace {
class PageInspectorProxy : public InspectorFrontendChannel {
WTF_MAKE_FAST_ALLOCATED;
public:
explicit PageInspectorProxy(WorkerContext* workerContext) : m_workerContext(workerContext) { }
virtual ~PageInspectorProxy() { }
private:
virtual bool sendMessageToFrontend(const String& message)
{
m_workerContext->thread()->workerReportingProxy().postMessageToPageInspector(message);
return true;
}
WorkerContext* m_workerContext;
};
class WorkerStateClient : public InspectorStateClient {
WTF_MAKE_FAST_ALLOCATED;
public:
WorkerStateClient(WorkerContext* context) : m_workerContext(context) { }
virtual ~WorkerStateClient() { }
private:
virtual bool supportsInspectorStateUpdates() const { return true; }
virtual void updateInspectorStateCookie(const String& cookie)
{
m_workerContext->thread()->workerReportingProxy().updateInspectorStateCookie(cookie);
}
WorkerContext* m_workerContext;
};
}
WorkerInspectorController::WorkerInspectorController(WorkerContext* workerContext)
: m_workerContext(workerContext)
, m_stateClient(adoptPtr(new WorkerStateClient(workerContext)))
, m_state(adoptPtr(new InspectorCompositeState(m_stateClient.get())))
, m_instrumentingAgents(InstrumentingAgents::create())
, m_injectedScriptManager(InjectedScriptManager::createForWorker())
, m_runtimeAgent(0)
{
OwnPtr<InspectorRuntimeAgent> runtimeAgent = WorkerRuntimeAgent::create(m_instrumentingAgents.get(), m_state.get(), m_injectedScriptManager.get(), workerContext);
m_runtimeAgent = runtimeAgent.get();
m_agents.append(runtimeAgent.release());
OwnPtr<InspectorConsoleAgent> consoleAgent = WorkerConsoleAgent::create(m_instrumentingAgents.get(), m_state.get(), m_injectedScriptManager.get());
#if ENABLE(JAVASCRIPT_DEBUGGER)
OwnPtr<InspectorDebuggerAgent> debuggerAgent = WorkerDebuggerAgent::create(m_instrumentingAgents.get(), m_state.get(), workerContext, m_injectedScriptManager.get());
InspectorDebuggerAgent* debuggerAgentPtr = debuggerAgent.get();
m_runtimeAgent->setScriptDebugServer(&debuggerAgent->scriptDebugServer());
m_agents.append(debuggerAgent.release());
m_agents.append(InspectorProfilerAgent::create(m_instrumentingAgents.get(), consoleAgent.get(), workerContext, m_state.get(), m_injectedScriptManager.get()));
m_agents.append(InspectorHeapProfilerAgent::create(m_instrumentingAgents.get(), m_state.get(), m_injectedScriptManager.get()));
#endif
m_agents.append(InspectorTimelineAgent::create(m_instrumentingAgents.get(), 0, 0, m_state.get(), InspectorTimelineAgent::WorkerInspector, 0));
m_agents.append(consoleAgent.release());
m_injectedScriptManager->injectedScriptHost()->init(0
, 0
#if ENABLE(SQL_DATABASE)
, 0
#endif
, 0
, 0
#if ENABLE(JAVASCRIPT_DEBUGGER)
, debuggerAgentPtr
#endif
);
}
WorkerInspectorController::~WorkerInspectorController()
{
m_instrumentingAgents->reset();
disconnectFrontend();
}
void WorkerInspectorController::connectFrontend()
{
ASSERT(!m_frontend);
m_state->unmute();
m_frontendChannel = adoptPtr(new PageInspectorProxy(m_workerContext));
m_frontend = adoptPtr(new InspectorFrontend(m_frontendChannel.get()));
m_backendDispatcher = InspectorBackendDispatcher::create(m_frontendChannel.get());
m_agents.registerInDispatcher(m_backendDispatcher.get());
m_agents.setFrontend(m_frontend.get());
}
void WorkerInspectorController::disconnectFrontend()
{
if (!m_frontend)
return;
m_backendDispatcher->clearFrontend();
m_backendDispatcher.clear();
m_state->mute();
m_agents.clearFrontend();
m_frontend.clear();
m_frontendChannel.clear();
}
void WorkerInspectorController::restoreInspectorStateFromCookie(const String& inspectorCookie)
{
ASSERT(!m_frontend);
connectFrontend();
m_state->loadFromCookie(inspectorCookie);
m_agents.restore();
}
void WorkerInspectorController::dispatchMessageFromFrontend(const String& message)
{
if (m_backendDispatcher)
m_backendDispatcher->dispatch(message);
}
#if ENABLE(JAVASCRIPT_DEBUGGER)
void WorkerInspectorController::resume()
{
ErrorString unused;
m_runtimeAgent->run(&unused);
}
#endif
}
#endif