DebuggerAgentManager.cpp [plain text]
#include "config.h"
#include "DebuggerAgentManager.h"
#include "DebuggerAgentImpl.h"
#include "Frame.h"
#include "PageGroupLoadDeferrer.h"
#include "ScriptDebugServer.h"
#include "V8Proxy.h"
#include "WebDevToolsAgentImpl.h"
#include "WebFrameImpl.h"
#include "WebViewImpl.h"
#include <wtf/HashSet.h>
#include <wtf/Noncopyable.h>
namespace WebKit {
WebDevToolsAgent::MessageLoopDispatchHandler DebuggerAgentManager::s_messageLoopDispatchHandler = 0;
bool DebuggerAgentManager::s_inHostDispatchHandler = false;
DebuggerAgentManager::DeferrersMap DebuggerAgentManager::s_pageDeferrers;
bool DebuggerAgentManager::s_inUtilityContext = false;
bool DebuggerAgentManager::s_debugBreakDelayed = false;
namespace {
class CallerIdWrapper : public v8::Debug::ClientData, public Noncopyable {
public:
CallerIdWrapper() : m_callerIsMananager(true), m_callerId(0) { }
explicit CallerIdWrapper(int callerId)
: m_callerIsMananager(false)
, m_callerId(callerId) { }
~CallerIdWrapper() { }
bool callerIsMananager() const { return m_callerIsMananager; }
int callerId() const { return m_callerId; }
private:
bool m_callerIsMananager;
int m_callerId;
};
}
void DebuggerAgentManager::hostDispatchHandler(const Vector<WebCore::Page*>& pages)
{
if (!s_messageLoopDispatchHandler)
return;
if (s_inHostDispatchHandler)
return;
s_inHostDispatchHandler = true;
Vector<WebViewImpl*> views;
for (size_t i = 0; i < pages.size(); i++) {
WebCore::Page* page = pages[i];
WebViewImpl* view = WebViewImpl::fromPage(page);
s_pageDeferrers.set(view , new WebCore::PageGroupLoadDeferrer(page, true));
views.append(view);
view->setIgnoreInputEvents(true);
}
s_messageLoopDispatchHandler();
for (Vector<WebViewImpl*>::iterator it = views.begin(); it != views.end(); ++it) {
if (s_pageDeferrers.contains(*it)) {
(*it)->setIgnoreInputEvents(false);
}
}
deleteAllValues(s_pageDeferrers);
s_pageDeferrers.clear();
s_inHostDispatchHandler = false;
}
void DebuggerAgentManager::debugHostDispatchHandler()
{
if (!s_messageLoopDispatchHandler || !s_attachedAgentsMap)
return;
if (s_inHostDispatchHandler)
return;
s_inHostDispatchHandler = true;
Vector<WebViewImpl*> views;
for (AttachedAgentsMap::iterator it = s_attachedAgentsMap->begin(); it != s_attachedAgentsMap->end(); ++it) {
DebuggerAgentImpl* agent = it->second;
s_pageDeferrers.set(agent->webView(), new WebCore::PageGroupLoadDeferrer(agent->page(), true));
views.append(agent->webView());
agent->webView()->setIgnoreInputEvents(true);
}
s_messageLoopDispatchHandler();
for (Vector<WebViewImpl*>::iterator it = views.begin(); it != views.end(); ++it) {
if (s_pageDeferrers.contains(*it)) {
(*it)->setIgnoreInputEvents(false);
}
}
deleteAllValues(s_pageDeferrers);
s_pageDeferrers.clear();
s_inHostDispatchHandler = false;
if (!s_attachedAgentsMap) {
v8::Debug::SetMessageHandler(0);
v8::Debug::SetHostDispatchHandler(0);
}
}
DebuggerAgentManager::AttachedAgentsMap* DebuggerAgentManager::s_attachedAgentsMap = 0;
void DebuggerAgentManager::debugAttach(DebuggerAgentImpl* debuggerAgent)
{
#if ENABLE(V8_SCRIPT_DEBUG_SERVER)
return;
#endif
if (!s_attachedAgentsMap) {
s_attachedAgentsMap = new AttachedAgentsMap();
v8::Debug::SetMessageHandler2(&DebuggerAgentManager::onV8DebugMessage);
v8::Debug::SetHostDispatchHandler(&DebuggerAgentManager::debugHostDispatchHandler, 100 );
}
int hostId = debuggerAgent->webdevtoolsAgent()->hostId();
ASSERT(hostId);
s_attachedAgentsMap->set(hostId, debuggerAgent);
}
void DebuggerAgentManager::debugDetach(DebuggerAgentImpl* debuggerAgent)
{
#if ENABLE(V8_SCRIPT_DEBUG_SERVER)
return;
#endif
if (!s_attachedAgentsMap) {
ASSERT_NOT_REACHED();
return;
}
int hostId = debuggerAgent->webdevtoolsAgent()->hostId();
ASSERT(s_attachedAgentsMap->get(hostId) == debuggerAgent);
bool isOnBreakpoint = (findAgentForCurrentV8Context() == debuggerAgent);
s_attachedAgentsMap->remove(hostId);
if (s_attachedAgentsMap->isEmpty()) {
delete s_attachedAgentsMap;
s_attachedAgentsMap = 0;
if (!s_inHostDispatchHandler) {
v8::Debug::SetMessageHandler2(0);
v8::Debug::SetHostDispatchHandler(0);
}
} else {
String clearBreakpointGroupCmd = String::format(
"{\"seq\":1,\"type\":\"request\",\"command\":\"clearbreakpointgroup\","
"\"arguments\":{\"groupId\":%d}}",
hostId);
sendCommandToV8(clearBreakpointGroupCmd, new CallerIdWrapper());
if (isOnBreakpoint) {
sendContinueCommandToV8();
}
}
}
void DebuggerAgentManager::onV8DebugMessage(const v8::Debug::Message& message)
{
v8::HandleScope scope;
v8::String::Value value(message.GetJSON());
String out(reinterpret_cast<const UChar*>(*value), value.length());
if (v8::Debug::ClientData* callerData = message.GetClientData()) {
CallerIdWrapper* wrapper = static_cast<CallerIdWrapper*>(callerData);
if (wrapper->callerIsMananager()) {
return;
}
DebuggerAgentImpl* debuggerAgent = debuggerAgentForHostId(wrapper->callerId());
if (debuggerAgent)
debuggerAgent->debuggerOutput(out);
else if (!message.WillStartRunning()) {
sendContinueCommandToV8();
}
return;
} ASSERT(message.IsEvent());
if (message.GetEvent() != v8::AfterCompile && message.GetEvent() != v8::Break && message.GetEvent() != v8::Exception)
return;
v8::Handle<v8::Context> context = message.GetEventContext();
if (context.IsEmpty()) {
return;
}
if (s_inUtilityContext && message.GetEvent() == v8::Break) {
s_debugBreakDelayed = true;
} else {
int hostId = WebCore::V8Proxy::contextDebugId(context);
if (hostId != -1) {
DebuggerAgentImpl* agent = debuggerAgentForHostId(hostId);
if (agent) {
if (agent->autoContinueOnException()
&& message.GetEvent() == v8::Exception) {
sendContinueCommandToV8();
return;
}
agent->debuggerOutput(out);
return;
}
}
}
if (!message.WillStartRunning()) {
sendContinueCommandToV8();
}
}
void DebuggerAgentManager::pauseScript()
{
if (s_inUtilityContext)
s_debugBreakDelayed = true;
else
v8::Debug::DebugBreak();
}
void DebuggerAgentManager::executeDebuggerCommand(const String& command, int callerId)
{
sendCommandToV8(command, new CallerIdWrapper(callerId));
}
void DebuggerAgentManager::setMessageLoopDispatchHandler(WebDevToolsAgent::MessageLoopDispatchHandler handler)
{
s_messageLoopDispatchHandler = handler;
WebCore::ScriptDebugServer::setMessageLoopDispatchHandler(DebuggerAgentManager::hostDispatchHandler);
}
void DebuggerAgentManager::setHostId(WebFrameImpl* webframe, int hostId)
{
ASSERT(hostId > 0);
WebCore::V8Proxy* proxy = WebCore::V8Proxy::retrieve(webframe->frame());
if (proxy)
proxy->setContextDebugId(hostId);
}
void DebuggerAgentManager::onWebViewClosed(WebViewImpl* webview)
{
if (s_pageDeferrers.contains(webview)) {
delete s_pageDeferrers.get(webview);
s_pageDeferrers.remove(webview);
}
}
void DebuggerAgentManager::onNavigate()
{
if (s_inHostDispatchHandler)
DebuggerAgentManager::sendContinueCommandToV8();
}
void DebuggerAgentManager::sendCommandToV8(const String& cmd, v8::Debug::ClientData* data)
{
v8::Debug::SendCommand(reinterpret_cast<const uint16_t*>(cmd.characters()), cmd.length(), data);
}
void DebuggerAgentManager::sendContinueCommandToV8()
{
String continueCmd("{\"seq\":1,\"type\":\"request\",\"command\":\"continue\"}");
sendCommandToV8(continueCmd, new CallerIdWrapper());
}
DebuggerAgentImpl* DebuggerAgentManager::findAgentForCurrentV8Context()
{
if (!s_attachedAgentsMap)
return 0;
ASSERT(!s_attachedAgentsMap->isEmpty());
WebCore::Frame* frame = WebCore::V8Proxy::retrieveFrameForEnteredContext();
if (!frame)
return 0;
WebCore::Page* page = frame->page();
for (AttachedAgentsMap::iterator it = s_attachedAgentsMap->begin(); it != s_attachedAgentsMap->end(); ++it) {
if (it->second->page() == page)
return it->second;
}
return 0;
}
DebuggerAgentImpl* DebuggerAgentManager::debuggerAgentForHostId(int hostId)
{
if (!s_attachedAgentsMap)
return 0;
return s_attachedAgentsMap->get(hostId);
}
}