Fixes a crash in JavaScriptDebugServer::returnEvent when debugging
[WebKit-https.git] / WebCore / page / JavaScriptDebugServer.cpp
1 /*
2  * Copyright (C) 2008 Apple 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
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "JavaScriptDebugServer.h"
31
32 #include "DOMWindow.h"
33 #include "EventLoop.h"
34 #include "Frame.h"
35 #include "FrameTree.h"
36 #include "FrameView.h"
37 #include "JSDOMWindow.h"
38 #include "JavaScriptCallFrame.h"
39 #include "JavaScriptDebugListener.h"
40 #include "kjs_proxy.h"
41 #include "Page.h"
42 #include "PageGroup.h"
43 #include "PluginView.h"
44 #include "ScrollView.h"
45 #include "Widget.h"
46 #include <wtf/MainThread.h>
47
48 using namespace KJS;
49
50 namespace WebCore {
51
52 typedef JavaScriptDebugServer::ListenerSet ListenerSet;
53
54 JavaScriptDebugServer& JavaScriptDebugServer::shared()
55 {
56     static JavaScriptDebugServer server;
57     return server;
58 }
59
60 JavaScriptDebugServer::JavaScriptDebugServer()
61     : m_callingListeners(false)
62     , m_pauseOnExceptions(false)
63     , m_pauseOnNextStatement(false)
64     , m_paused(false)
65     , m_pauseOnExecState(0)
66 {
67 }
68
69 JavaScriptDebugServer::~JavaScriptDebugServer()
70 {
71     deleteAllValues(m_pageListenersMap);
72     deleteAllValues(m_breakpoints);
73 }
74
75 void JavaScriptDebugServer::addListener(JavaScriptDebugListener* listener)
76 {
77     if (!hasListeners())
78         Page::setDebuggerForAllPages(this);
79
80     m_listeners.add(listener);
81 }
82
83 void JavaScriptDebugServer::removeListener(JavaScriptDebugListener* listener)
84 {
85     m_listeners.remove(listener);
86     if (!hasListeners()) {
87         Page::setDebuggerForAllPages(0);
88         resume();
89     }
90 }
91
92 void JavaScriptDebugServer::addListener(JavaScriptDebugListener* listener, Page* page)
93 {
94     ASSERT_ARG(page, page);
95
96     if (!hasListeners())
97         Page::setDebuggerForAllPages(this);
98
99     pair<PageListenersMap::iterator, bool> result = m_pageListenersMap.add(page, 0);
100     if (result.second)
101         result.first->second = new ListenerSet;
102     ListenerSet* listeners = result.first->second;
103
104     listeners->add(listener);
105 }
106
107 void JavaScriptDebugServer::removeListener(JavaScriptDebugListener* listener, Page* page)
108 {
109     ASSERT_ARG(page, page);
110
111     PageListenersMap::iterator it = m_pageListenersMap.find(page);
112     if (it == m_pageListenersMap.end())
113         return;
114
115     ListenerSet* listeners = it->second;
116
117     listeners->remove(listener);
118
119     if (listeners->isEmpty()) {
120         m_pageListenersMap.remove(it);
121         delete listeners;
122     }
123
124     if (!hasListeners()) {
125         Page::setDebuggerForAllPages(0);
126         resume();
127     }
128 }
129
130 void JavaScriptDebugServer::pageCreated(Page* page)
131 {
132     if (!hasListeners())
133         return;
134
135     page->setDebugger(this);
136 }
137
138 bool JavaScriptDebugServer::hasListenersInterestedInPage(Page* page)
139 {
140     ASSERT_ARG(page, page);
141
142     if (!m_listeners.isEmpty())
143         return true;
144
145     return m_pageListenersMap.contains(page);
146 }
147
148 void JavaScriptDebugServer::addBreakpoint(int sourceID, unsigned lineNumber)
149 {
150     HashSet<unsigned>* lines = m_breakpoints.get(sourceID);
151     if (!lines) {
152         lines = new HashSet<unsigned>;
153         m_breakpoints.set(sourceID, lines);
154     }
155
156     lines->add(lineNumber);
157 }
158
159 void JavaScriptDebugServer::removeBreakpoint(int sourceID, unsigned lineNumber)
160 {
161     HashSet<unsigned>* lines = m_breakpoints.get(sourceID);
162     if (!lines)
163         return;
164
165     lines->remove(lineNumber);
166
167     if (!lines->isEmpty())
168         return;
169
170     m_breakpoints.remove(sourceID);
171     delete lines;
172 }
173
174 bool JavaScriptDebugServer::hasBreakpoint(int sourceID, unsigned lineNumber) const
175 {
176     HashSet<unsigned>* lines = m_breakpoints.get(sourceID);
177     if (!lines)
178         return false;
179     return lines->contains(lineNumber);
180 }
181
182 void JavaScriptDebugServer::clearBreakpoints()
183 {
184     deleteAllValues(m_breakpoints);
185     m_breakpoints.clear();
186 }
187
188 void JavaScriptDebugServer::setPauseOnExceptions(bool pause)
189 {
190     m_pauseOnExceptions = pause;
191 }
192
193 void JavaScriptDebugServer::pauseOnNextStatement()
194 {
195     m_pauseOnNextStatement = true;
196 }
197
198 void JavaScriptDebugServer::resume()
199 {
200     m_paused = false;
201 }
202
203 void JavaScriptDebugServer::stepIntoStatement()
204 {
205     if (!m_paused)
206         return;
207
208     resume();
209
210     m_pauseOnNextStatement = true;
211 }
212
213 void JavaScriptDebugServer::stepOverStatement()
214 {
215     if (!m_paused)
216         return;
217
218     resume();
219
220     if (m_currentCallFrame)
221         m_pauseOnExecState = m_currentCallFrame->execState();
222     else
223         m_pauseOnExecState = 0;
224 }
225
226 void JavaScriptDebugServer::stepOutOfFunction()
227 {
228     if (!m_paused)
229         return;
230
231     resume();
232
233     if (m_currentCallFrame && m_currentCallFrame->caller())
234         m_pauseOnExecState = m_currentCallFrame->caller()->execState();
235     else
236         m_pauseOnExecState = 0;
237 }
238
239 JavaScriptCallFrame* JavaScriptDebugServer::currentCallFrame()
240 {
241     if (!m_paused)
242         return 0;
243     return m_currentCallFrame.get();
244 }
245
246 static void dispatchDidParseSource(const ListenerSet& listeners, const UString& source, int startingLineNumber, const UString& sourceURL, int sourceID)
247 {
248     Vector<JavaScriptDebugListener*> copy;
249     copyToVector(listeners, copy);
250     for (size_t i = 0; i < copy.size(); ++i)
251         copy[i]->didParseSource(source, startingLineNumber, sourceURL, sourceID);
252 }
253
254 static void dispatchFailedToParseSource(const ListenerSet& listeners, const UString& source, int startingLineNumber, const UString& sourceURL, int errorLine, const UString& errorMessage)
255 {
256     Vector<JavaScriptDebugListener*> copy;
257     copyToVector(listeners, copy);
258     for (size_t i = 0; i < copy.size(); ++i)
259         copy[i]->failedToParseSource(source, startingLineNumber, sourceURL, errorLine, errorMessage);
260 }
261
262 static Page* toPage(ExecState* exec)
263 {
264     ASSERT_ARG(exec, exec);
265
266     JSDOMWindow* window = asJSDOMWindow(exec->dynamicGlobalObject());
267     ASSERT(window);
268
269     return window->impl()->frame()->page();
270 }
271
272 #ifdef DEBUG_DEBUGGER_CALLBACKS
273 static unsigned s_callDepth = 0;
274 #endif
275
276 bool JavaScriptDebugServer::sourceParsed(ExecState* exec, int sourceID, const UString& sourceURL, const UString& source, int startingLineNumber, int errorLine, const UString& errorMessage)
277 {
278     if (m_callingListeners)
279         return true;
280
281     Page* page = toPage(exec);
282     if (!page)
283         return true;
284
285     m_callingListeners = true;
286
287     ASSERT(hasListeners());
288
289     bool isError = errorLine != -1;
290
291 #ifdef DEBUG_DEBUGGER_CALLBACKS
292     printf("source: ");
293     for(unsigned i = 0; i < s_callDepth; ++i)
294         printf(" ");
295     printf("%d: '%s' exec: %p (caller: %p) source: %d\n", s_callDepth, sourceURL.ascii(), exec, exec->callingExecState(), sourceID);
296 #endif
297
298     if (!m_listeners.isEmpty()) {
299         if (isError)
300             dispatchFailedToParseSource(m_listeners, source, startingLineNumber, sourceURL, errorLine, errorMessage);
301         else
302             dispatchDidParseSource(m_listeners, source, startingLineNumber, sourceURL, sourceID);
303     }
304
305     if (ListenerSet* pageListeners = m_pageListenersMap.get(page)) {
306         ASSERT(!pageListeners->isEmpty());
307         if (isError)
308             dispatchFailedToParseSource(*pageListeners, source, startingLineNumber, sourceURL, errorLine, errorMessage);
309         else
310             dispatchDidParseSource(*pageListeners, source, startingLineNumber, sourceURL, sourceID);
311     }
312
313     m_callingListeners = false;
314     return true;
315 }
316
317 static void dispatchFunctionToListeners(const ListenerSet& listeners, JavaScriptDebugServer::JavaScriptExecutionCallback callback)
318 {
319     Vector<JavaScriptDebugListener*> copy;
320     copyToVector(listeners, copy);
321     for (size_t i = 0; i < copy.size(); ++i)
322         (copy[i]->*callback)();
323 }
324
325 void JavaScriptDebugServer::dispatchFunctionToListeners(JavaScriptExecutionCallback callback, ExecState* exec)
326 {
327     if (m_callingListeners)
328         return;
329
330     Page* page = toPage(exec);
331     if (!page)
332         return;
333
334     m_callingListeners = true;
335
336     ASSERT(hasListeners());
337
338     WebCore::dispatchFunctionToListeners(m_listeners, callback);
339     if (ListenerSet* pageListeners = m_pageListenersMap.get(page)) {
340         ASSERT(!pageListeners->isEmpty());
341         WebCore::dispatchFunctionToListeners(*pageListeners, callback);
342     }
343
344     m_callingListeners = false;
345 }
346
347 void JavaScriptDebugServer::setJavaScriptPaused(const PageGroup& pageGroup, bool paused)
348 {
349     setMainThreadCallbacksPaused(paused);
350
351     const HashSet<Page*>& pages = pageGroup.pages();
352
353     HashSet<Page*>::const_iterator end = pages.end();
354     for (HashSet<Page*>::const_iterator it = pages.begin(); it != end; ++it)
355         setJavaScriptPaused(*it, false);
356 }
357
358 void JavaScriptDebugServer::setJavaScriptPaused(Page* page, bool paused)
359 {
360     ASSERT_ARG(page, page);
361
362     page->setDefersLoading(paused);
363
364     for (Frame* frame = page->mainFrame(); frame; frame = frame->tree()->traverseNext())
365         setJavaScriptPaused(frame, paused);
366 }
367
368 void JavaScriptDebugServer::setJavaScriptPaused(Frame* frame, bool paused)
369 {
370     ASSERT_ARG(frame, frame);
371
372     if (!frame->scriptProxy()->isEnabled())
373         return;
374
375     frame->scriptProxy()->setPaused(paused);
376
377     if (JSDOMWindow* window = toJSDOMWindow(frame)) {
378         if (paused)
379             m_pausedTimeouts.set(frame, window->pauseTimeouts());
380         else
381             window->resumeTimeouts(m_pausedTimeouts.take(frame));
382     }
383
384     setJavaScriptPaused(frame->view(), paused);
385 }
386
387 void JavaScriptDebugServer::setJavaScriptPaused(FrameView* view, bool paused)
388 {
389 #if !PLATFORM(MAC)
390     if (!view)
391         return;
392
393     HashSet<Widget*>* children = static_cast<ScrollView*>(view)->children();
394     ASSERT(children);
395
396     HashSet<Widget*>::iterator end = children->end();
397     for (HashSet<Widget*>::iterator it = children->begin(); it != end; ++it) {
398         Widget* widget = *it;
399         if (!widget->isPluginView())
400             continue;
401         static_cast<PluginView*>(widget)->setJavaScriptPaused(paused);
402     }
403 #endif
404 }
405
406 void JavaScriptDebugServer::pauseIfNeeded(ExecState* exec, int sourceID, int lineNumber)
407 {
408     if (m_paused)
409         return;
410
411     Page* page = toPage(exec);
412     if (!page || !hasListenersInterestedInPage(page))
413         return;
414
415     bool pauseNow = m_pauseOnNextStatement;
416     if (!pauseNow && m_pauseOnExecState)
417         pauseNow = (m_pauseOnExecState == exec);
418     if (!pauseNow && lineNumber > 0)
419         pauseNow = hasBreakpoint(sourceID, lineNumber);
420     if (!pauseNow)
421         return;
422
423     m_pauseOnExecState = 0;
424     m_pauseOnNextStatement = false;
425     m_paused = true;
426
427     dispatchFunctionToListeners(&JavaScriptDebugListener::didPause, exec);
428
429     setJavaScriptPaused(page->group(), true);
430
431     EventLoop loop;
432     while (m_paused && !loop.ended())
433         loop.cycle();
434
435     setJavaScriptPaused(page->group(), false);
436
437     m_paused = false;
438 }
439
440 static inline void updateCurrentCallFrame(RefPtr<JavaScriptCallFrame>& currentCallFrame, ExecState* exec, int sourceID, int lineNumber, ExecState*& pauseExecState)
441 {
442 #ifdef DEBUG_DEBUGGER_CALLBACKS
443     const char* action = 0;
444 #endif
445
446     if (currentCallFrame) {
447         if (currentCallFrame->execState() == exec) {
448             // Same call frame, just update the current line.
449             currentCallFrame->setLine(lineNumber);
450 #ifdef DEBUG_DEBUGGER_CALLBACKS
451             action = "  same";
452 #endif
453         } else if (currentCallFrame->execState() == exec->callingExecState()) {
454             // Create a new call frame, and make the caller the previous call frame.
455             currentCallFrame = JavaScriptCallFrame::create(exec, currentCallFrame, sourceID, lineNumber);
456 #ifdef DEBUG_DEBUGGER_CALLBACKS
457             action = "  call";
458             ++s_callDepth;
459 #endif
460         } else {
461 #ifdef DEBUG_DEBUGGER_CALLBACKS
462             action = "return";
463 #endif
464             // The current call frame isn't the same and it isn't the caller of a new call frame,
465             // so it might be a previous call frame (returning from a function). Or it is a stale call
466             // frame from the previous execution of global code. Walk up the caller chain until we find
467             // the current exec state. If the current exec state is found, the current call frame will be
468             // set to null (and a new one will be created below.)
469             while (currentCallFrame && currentCallFrame->execState() != exec) {
470                 if (currentCallFrame->execState() == pauseExecState) {
471                     // The current call frame matches the pause exec state (used for step over.)
472                     // Since we are returning up the call stack, update the pause exec state to match.
473                     // This makes stepping over a return statement act like a step out.
474                     if (currentCallFrame->caller())
475                         pauseExecState = currentCallFrame->caller()->execState();
476                     else
477                         pauseExecState = 0;
478                 }
479
480                 // Invalidate the call frame since it's ExecState is stale now.
481                 currentCallFrame->invalidate();
482                 currentCallFrame = currentCallFrame->caller();
483
484 #ifdef DEBUG_DEBUGGER_CALLBACKS
485                 if (s_callDepth)
486                     --s_callDepth;
487 #endif
488             }
489
490             if (currentCallFrame)
491                 currentCallFrame->setLine(lineNumber);
492         }
493     }
494
495     if (!currentCallFrame) {
496         // Create a new call frame with no caller, this is likely global code.
497         currentCallFrame = JavaScriptCallFrame::create(exec, 0, sourceID, lineNumber);
498 #ifdef DEBUG_DEBUGGER_CALLBACKS
499         action = "   new";
500 #endif
501     }
502
503 #ifdef DEBUG_DEBUGGER_CALLBACKS
504     printf("%s: ", action);
505     for(unsigned i = 0; i < s_callDepth; ++i)
506         printf(" ");
507     printf("%d: at exec: %p (caller: %p, pause: %p) source: %d line: %d\n", s_callDepth, exec, exec->callingExecState(), pauseExecState, sourceID, lineNumber);
508 #endif
509 }
510
511 bool JavaScriptDebugServer::callEvent(ExecState* exec, int sourceID, int lineNumber, JSObject*, const List&)
512 {
513     if (m_paused)
514         return true;
515     updateCurrentCallFrame(m_currentCallFrame, exec, sourceID, lineNumber, m_pauseOnExecState);
516     pauseIfNeeded(exec, sourceID, lineNumber);
517     return true;
518 }
519
520 bool JavaScriptDebugServer::atStatement(ExecState* exec, int sourceID, int firstLine, int)
521 {
522     if (m_paused)
523         return true;
524     updateCurrentCallFrame(m_currentCallFrame, exec, sourceID, firstLine, m_pauseOnExecState);
525     pauseIfNeeded(exec, sourceID, firstLine);
526     return true;
527 }
528
529 bool JavaScriptDebugServer::returnEvent(ExecState* exec, int sourceID, int lineNumber, JSObject*)
530 {
531     if (m_paused)
532         return true;
533     updateCurrentCallFrame(m_currentCallFrame, exec, sourceID, lineNumber, m_pauseOnExecState);
534     pauseIfNeeded(exec, sourceID, lineNumber);
535     return true;
536 }
537
538 bool JavaScriptDebugServer::exception(ExecState* exec, int sourceID, int lineNumber, JSValue*)
539 {
540     if (m_paused)
541         return true;
542     updateCurrentCallFrame(m_currentCallFrame, exec, sourceID, lineNumber, m_pauseOnExecState);
543     if (m_pauseOnExceptions)
544         m_pauseOnNextStatement = true;
545     pauseIfNeeded(exec, sourceID, lineNumber);
546     return true;
547 }
548
549 } // namespace WebCore