Source/WebKit/chromium/src/DebuggerAgentManager.cpp

   1 /*
   2  * Copyright (C) 2010 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "DebuggerAgentManager.h"
  33
  34 #include "DebuggerAgentImpl.h"
  35 #include "Frame.h"
  36 #include "PageGroupLoadDeferrer.h"
  37 #include "PageScriptDebugServer.h"
  38 #include "V8Proxy.h"
  39 #include "WebDevToolsAgentImpl.h"
  40 #include "WebFrameImpl.h"
  41 #include "WebViewImpl.h"
  42 #include <wtf/HashSet.h>
  43 #include <wtf/Noncopyable.h>
  44 #include <wtf/text/StringConcatenate.h>
  45
  46 namespace WebKit {
  47
  48 WebDevToolsAgent::MessageLoopDispatchHandler DebuggerAgentManager::s_messageLoopDispatchHandler = 0;
  49
  50 bool DebuggerAgentManager::s_inHostDispatchHandler = false;
  51
  52 DebuggerAgentManager::DeferrersMap DebuggerAgentManager::s_pageDeferrers;
  53
  54 bool DebuggerAgentManager::s_exposeV8DebuggerProtocol = false;
  55
  56 namespace {
  57
  58 class CallerIdWrapper : public v8::Debug::ClientData {
  59     WTF_MAKE_NONCOPYABLE(CallerIdWrapper);
  60 public:
  61     CallerIdWrapper() : m_callerIsMananager(true), m_callerId(0) { }
  62     explicit CallerIdWrapper(int callerId)
  63         : m_callerIsMananager(false)
  64         , m_callerId(callerId) { }
  65     ~CallerIdWrapper() { }
  66     bool callerIsMananager() const { return m_callerIsMananager; }
  67     int callerId() const { return m_callerId; }
  68 private:
  69     bool m_callerIsMananager;
  70     int m_callerId;
  71 };
  72
  73 } // namespace
  74
  75
  76 void DebuggerAgentManager::debugHostDispatchHandler()
  77 {
  78     if (!s_messageLoopDispatchHandler || !s_attachedAgentsMap)
  79         return;
  80
  81     if (s_inHostDispatchHandler)
  82         return;
  83
  84     s_inHostDispatchHandler = true;
  85
  86     Vector<WebViewImpl*> views;
  87     // 1. Disable active objects and input events.
  88     for (AttachedAgentsMap::iterator it = s_attachedAgentsMap->begin(); it != s_attachedAgentsMap->end(); ++it) {
  89         DebuggerAgentImpl* agent = it->second;
  90         s_pageDeferrers.set(agent->webView(), new WebCore::PageGroupLoadDeferrer(agent->page(), true));
  91         views.append(agent->webView());
  92         agent->webView()->setIgnoreInputEvents(true);
  93     }
  94
  95     // 2. Process messages.
  96     s_messageLoopDispatchHandler();
  97
  98     // 3. Bring things back.
  99     for (Vector<WebViewImpl*>::iterator it = views.begin(); it != views.end(); ++it) {
 100         if (s_pageDeferrers.contains(*it)) {
 101             // The view was not closed during the dispatch.
 102             (*it)->setIgnoreInputEvents(false);
 103         }
 104     }
 105     deleteAllValues(s_pageDeferrers);
 106     s_pageDeferrers.clear();
 107
 108     s_inHostDispatchHandler = false;
 109     if (!s_attachedAgentsMap) {
 110         // Remove handlers if all agents were detached within host dispatch.
 111         v8::Debug::SetMessageHandler(0);
 112         v8::Debug::SetHostDispatchHandler(0);
 113     }
 114 }
 115
 116 DebuggerAgentManager::AttachedAgentsMap* DebuggerAgentManager::s_attachedAgentsMap = 0;
 117
 118 void DebuggerAgentManager::debugAttach(DebuggerAgentImpl* debuggerAgent)
 119 {
 120     if (!s_exposeV8DebuggerProtocol)
 121         return;
 122     if (!s_attachedAgentsMap) {
 123         s_attachedAgentsMap = new AttachedAgentsMap();
 124         v8::Debug::SetMessageHandler2(&DebuggerAgentManager::onV8DebugMessage);
 125         v8::Debug::SetHostDispatchHandler(&DebuggerAgentManager::debugHostDispatchHandler, 100 /* ms */);
 126     }
 127     int hostId = debuggerAgent->webdevtoolsAgent()->hostId();
 128     ASSERT(hostId);
 129     s_attachedAgentsMap->set(hostId, debuggerAgent);
 130 }
 131
 132 void DebuggerAgentManager::debugDetach(DebuggerAgentImpl* debuggerAgent)
 133 {
 134     if (!s_exposeV8DebuggerProtocol)
 135         return;
 136     if (!s_attachedAgentsMap) {
 137         ASSERT_NOT_REACHED();
 138         return;
 139     }
 140     int hostId = debuggerAgent->webdevtoolsAgent()->hostId();
 141     ASSERT(s_attachedAgentsMap->get(hostId) == debuggerAgent);
 142     bool isOnBreakpoint = (findAgentForCurrentV8Context() == debuggerAgent);
 143     s_attachedAgentsMap->remove(hostId);
 144
 145     if (s_attachedAgentsMap->isEmpty()) {
 146         delete s_attachedAgentsMap;
 147         s_attachedAgentsMap = 0;
 148         // Note that we do not empty handlers while in dispatch - we schedule
 149         // continue and do removal once we are out of the dispatch. Also there is
 150         // no need to send continue command in this case since removing message
 151         // handler will cause debugger unload and all breakpoints will be cleared.
 152         if (!s_inHostDispatchHandler) {
 153             v8::Debug::SetMessageHandler2(0);
 154             v8::Debug::SetHostDispatchHandler(0);
 155         }
 156     } else {
 157       // Remove all breakpoints set by the agent.
 158       String clearBreakpointGroupCmd = makeString(
 159           "{\"seq\":1,\"type\":\"request\",\"command\":\"clearbreakpointgroup\","
 160               "\"arguments\":{\"groupId\":", String::number(hostId), "}}");
 161       sendCommandToV8(clearBreakpointGroupCmd, new CallerIdWrapper());
 162
 163       if (isOnBreakpoint) {
 164           // Force continue if detach happened in nessted message loop while
 165           // debugger was paused on a breakpoint(as long as there are other
 166           // attached agents v8 will wait for explicit'continue' message).
 167           sendContinueCommandToV8();
 168       }
 169     }
 170 }
 171
 172 void DebuggerAgentManager::onV8DebugMessage(const v8::Debug::Message& message)
 173 {
 174     v8::HandleScope scope;
 175     v8::String::Value value(message.GetJSON());
 176     WTF::String out(reinterpret_cast<const UChar*>(*value), value.length());
 177
 178     // If callerData is not 0 the message is a response to a debugger command.
 179     if (v8::Debug::ClientData* callerData = message.GetClientData()) {
 180         CallerIdWrapper* wrapper = static_cast<CallerIdWrapper*>(callerData);
 181         if (wrapper->callerIsMananager()) {
 182             // Just ignore messages sent by this manager.
 183             return;
 184         }
 185         DebuggerAgentImpl* debuggerAgent = debuggerAgentForHostId(wrapper->callerId());
 186         if (debuggerAgent)
 187             debuggerAgent->debuggerOutput(out);
 188         else if (!message.WillStartRunning()) {
 189             // Autocontinue execution if there is no handler.
 190             sendContinueCommandToV8();
 191         }
 192         return;
 193     } // Otherwise it's an event message.
 194     ASSERT(message.IsEvent());
 195
 196     // Ignore unsupported event types.
 197     if (message.GetEvent() != v8::AfterCompile && message.GetEvent() != v8::Break && message.GetEvent() != v8::Exception)
 198         return;
 199
 200     v8::Handle<v8::Context> context = message.GetEventContext();
 201     // If the context is from one of the inpected tabs it should have its context
 202     // data.
 203     if (context.IsEmpty()) {
 204         // Unknown context, skip the event.
 205         return;
 206     }
 207
 208     // If the context is from one of the inpected tabs or injected extension
 209     // scripts it must have hostId in the data field.
 210     int hostId = WebCore::V8Proxy::contextDebugId(context);
 211     if (hostId != -1) {
 212         DebuggerAgentImpl* agent = debuggerAgentForHostId(hostId);
 213         if (agent) {
 214             if (agent->autoContinueOnException()
 215                 && message.GetEvent() == v8::Exception) {
 216                 sendContinueCommandToV8();
 217                 return;
 218             }
 219
 220             agent->debuggerOutput(out);
 221             return;
 222         }
 223     }
 224
 225     if (!message.WillStartRunning()) {
 226         // Autocontinue execution on break and exception  events if there is no
 227         // handler.
 228         sendContinueCommandToV8();
 229     }
 230 }
 231
 232 void DebuggerAgentManager::pauseScript()
 233 {
 234     v8::Debug::DebugBreak();
 235 }
 236
 237 void DebuggerAgentManager::executeDebuggerCommand(const WTF::String& command, int callerId)
 238 {
 239     sendCommandToV8(command, new CallerIdWrapper(callerId));
 240 }
 241
 242 void DebuggerAgentManager::setMessageLoopDispatchHandler(WebDevToolsAgent::MessageLoopDispatchHandler handler)
 243 {
 244     s_messageLoopDispatchHandler = handler;
 245 }
 246
 247 void DebuggerAgentManager::setExposeV8DebuggerProtocol(bool value)
 248 {
 249     s_exposeV8DebuggerProtocol = value;
 250     WebCore::PageScriptDebugServer::shared().setEnabled(!s_exposeV8DebuggerProtocol);
 251 }
 252
 253 void DebuggerAgentManager::setHostId(WebFrameImpl* webframe, int hostId)
 254 {
 255     ASSERT(hostId > 0);
 256     WebCore::V8Proxy* proxy = WebCore::V8Proxy::retrieve(webframe->frame());
 257     if (proxy)
 258         proxy->setContextDebugId(hostId);
 259 }
 260
 261 void DebuggerAgentManager::onWebViewClosed(WebViewImpl* webview)
 262 {
 263     if (s_pageDeferrers.contains(webview)) {
 264         delete s_pageDeferrers.get(webview);
 265         s_pageDeferrers.remove(webview);
 266     }
 267 }
 268
 269 void DebuggerAgentManager::onNavigate()
 270 {
 271     if (s_inHostDispatchHandler)
 272         DebuggerAgentManager::sendContinueCommandToV8();
 273 }
 274
 275 void DebuggerAgentManager::sendCommandToV8(const WTF::String& cmd, v8::Debug::ClientData* data)
 276 {
 277     v8::Debug::SendCommand(reinterpret_cast<const uint16_t*>(cmd.characters()), cmd.length(), data);
 278 }
 279
 280 void DebuggerAgentManager::sendContinueCommandToV8()
 281 {
 282     WTF::String continueCmd("{\"seq\":1,\"type\":\"request\",\"command\":\"continue\"}");
 283     sendCommandToV8(continueCmd, new CallerIdWrapper());
 284 }
 285
 286 DebuggerAgentImpl* DebuggerAgentManager::findAgentForCurrentV8Context()
 287 {
 288     if (!s_attachedAgentsMap)
 289         return 0;
 290     ASSERT(!s_attachedAgentsMap->isEmpty());
 291
 292     WebCore::Frame* frame = WebCore::V8Proxy::retrieveFrameForEnteredContext();
 293     if (!frame)
 294         return 0;
 295     WebCore::Page* page = frame->page();
 296     for (AttachedAgentsMap::iterator it = s_attachedAgentsMap->begin(); it != s_attachedAgentsMap->end(); ++it) {
 297         if (it->second->page() == page)
 298             return it->second;
 299     }
 300     return 0;
 301 }
 302
 303 DebuggerAgentImpl* DebuggerAgentManager::debuggerAgentForHostId(int hostId)
 304 {
 305     if (!s_attachedAgentsMap)
 306         return 0;
 307     return s_attachedAgentsMap->get(hostId);
 308 }
 309
 310 } // namespace WebKit