Changeset 69014 in webkit


Ignore:
Timestamp:
Oct 4, 2010 7:52:38 AM (14 years ago)
Author:
podivilov@chromium.org
Message:

2010-10-04 ​podivilov@chromium.org <​podivilov@chromium.org>

Reviewed by Yury Semikhatsky.

Web Inspector: implement pausing on event listeners (back-end part)
​https://bugs.webkit.org/show_bug.cgi?id=46624

  • bindings/js/ScriptDebugServer.cpp: (WebCore::ScriptDebugServer::setPauseOnNextStatement):
  • bindings/js/ScriptDebugServer.h:
  • bindings/v8/ScriptDebugServer.cpp: (WebCore::ScriptDebugServer::setPauseOnNextStatement):
  • bindings/v8/ScriptDebugServer.h:
  • dom/Node.cpp: (WebCore::Node::dispatchGenericEvent):
  • inspector/InspectorController.cpp: (WebCore::InspectorController::didCommitLoad): (WebCore::InspectorController::setNativeBreakpoint): (WebCore::InspectorController::removeNativeBreakpoint): (WebCore::InspectorController::shouldBreakOnEvent): (WebCore::InspectorController::shouldBreakOnXMLHttpRequest):
  • inspector/InspectorController.h:
  • inspector/InspectorDebuggerAgent.cpp: (WebCore::InspectorDebuggerAgent::~InspectorDebuggerAgent): (WebCore::InspectorDebuggerAgent::schedulePauseOnNextStatement): (WebCore::InspectorDebuggerAgent::cancelPauseOnNextStatement): (WebCore::InspectorDebuggerAgent::pause): (WebCore::InspectorDebuggerAgent::didContinue): (WebCore::InspectorDebuggerAgent::breakProgram):
  • inspector/InspectorDebuggerAgent.h:
  • inspector/InspectorInstrumentation.cpp: (WebCore::eventHasListeners): (WebCore::InspectorInstrumentation::instrumentWillDispatchEventImpl): (WebCore::InspectorInstrumentation::instrumentDidDispatchEventImpl): (WebCore::InspectorInstrumentation::instrumentWillSendXMLHttpRequestImpl):
  • inspector/InspectorInstrumentation.h: (WebCore::InspectorInstrumentation::instrumentWillDispatchEvent): (WebCore::InspectorInstrumentation::instrumentDidDispatchEvent): (WebCore::InspectorInstrumentation::instrumentWillSendXMLHttpRequest):
  • inspector/InspectorTimelineAgent.cpp: (WebCore::InspectorTimelineAgent::InspectorTimelineAgent):
  • inspector/InspectorTimelineAgent.h: (WebCore::InspectorTimelineAgent::id):
  • inspector/front-end/CallStackSidebarPane.js:
Location:
trunk/WebCore
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r69010 r69014  
     12010-10-04  podivilov@chromium.org  <podivilov@chromium.org>
     2
     3        Reviewed by Yury Semikhatsky.
     4
     5        Web Inspector: implement pausing on event listeners (back-end part)
     6        https://bugs.webkit.org/show_bug.cgi?id=46624
     7
     8        * bindings/js/ScriptDebugServer.cpp:
     9        (WebCore::ScriptDebugServer::setPauseOnNextStatement):
     10        * bindings/js/ScriptDebugServer.h:
     11        * bindings/v8/ScriptDebugServer.cpp:
     12        (WebCore::ScriptDebugServer::setPauseOnNextStatement):
     13        * bindings/v8/ScriptDebugServer.h:
     14        * dom/Node.cpp:
     15        (WebCore::Node::dispatchGenericEvent):
     16        * inspector/InspectorController.cpp:
     17        (WebCore::InspectorController::didCommitLoad):
     18        (WebCore::InspectorController::setNativeBreakpoint):
     19        (WebCore::InspectorController::removeNativeBreakpoint):
     20        (WebCore::InspectorController::shouldBreakOnEvent):
     21        (WebCore::InspectorController::shouldBreakOnXMLHttpRequest):
     22        * inspector/InspectorController.h:
     23        * inspector/InspectorDebuggerAgent.cpp:
     24        (WebCore::InspectorDebuggerAgent::~InspectorDebuggerAgent):
     25        (WebCore::InspectorDebuggerAgent::schedulePauseOnNextStatement):
     26        (WebCore::InspectorDebuggerAgent::cancelPauseOnNextStatement):
     27        (WebCore::InspectorDebuggerAgent::pause):
     28        (WebCore::InspectorDebuggerAgent::didContinue):
     29        (WebCore::InspectorDebuggerAgent::breakProgram):
     30        * inspector/InspectorDebuggerAgent.h:
     31        * inspector/InspectorInstrumentation.cpp:
     32        (WebCore::eventHasListeners):
     33        (WebCore::InspectorInstrumentation::instrumentWillDispatchEventImpl):
     34        (WebCore::InspectorInstrumentation::instrumentDidDispatchEventImpl):
     35        (WebCore::InspectorInstrumentation::instrumentWillSendXMLHttpRequestImpl):
     36        * inspector/InspectorInstrumentation.h:
     37        (WebCore::InspectorInstrumentation::instrumentWillDispatchEvent):
     38        (WebCore::InspectorInstrumentation::instrumentDidDispatchEvent):
     39        (WebCore::InspectorInstrumentation::instrumentWillSendXMLHttpRequest):
     40        * inspector/InspectorTimelineAgent.cpp:
     41        (WebCore::InspectorTimelineAgent::InspectorTimelineAgent):
     42        * inspector/InspectorTimelineAgent.h:
     43        (WebCore::InspectorTimelineAgent::id):
     44        * inspector/front-end/CallStackSidebarPane.js:
     45
    1462010-10-04  Pavel Feldman  <pfeldman@chromium.org>
    247

  • trunk/WebCore/bindings/js/ScriptDebugServer.cpp

    r67432 r69014  
    201201}
    202202
    203 void ScriptDebugServer::pause()
    204 {
    205     m_pauseOnNextStatement = true;
     203void ScriptDebugServer::setPauseOnNextStatement(bool pause)
     204{
     205    m_pauseOnNextStatement = pause;
    206206}
    207207

  • trunk/WebCore/bindings/js/ScriptDebugServer.h

    r65731 r69014  
    7979    void setPauseOnExceptionsState(PauseOnExceptionsState);
    8080
    81     void pause();
     81    void setPauseOnNextStatement(bool pause);
    8282    void breakProgram();
    8383    void continueProgram();

  • trunk/WebCore/bindings/v8/ScriptDebugServer.cpp

    r66013 r69014  
    226226}
    227227
    228 void ScriptDebugServer::pause()
    229 {
    230     if (!m_pausedPage)
     228void ScriptDebugServer::setPauseOnNextStatement(bool pause)
     229{
     230    if (m_pausedPage)
     231        return;
     232    if (pause)
    231233        v8::Debug::DebugBreak();
     234    else
     235        v8::Debug::CancelDebugBreak();
    232236}
    233237

  • trunk/WebCore/bindings/v8/ScriptDebugServer.h

    r66013 r69014  
    7171    void setPauseOnExceptionsState(PauseOnExceptionsState pauseOnExceptionsState);
    7272
    73     void pause();
     73    void setPauseOnNextStatement(bool pause);
    7474    void breakProgram();
    7575    void continueProgram();

  • trunk/WebCore/dom/Node.cpp

    r68541 r69014  
    5454#include "FrameView.h"
    5555#include "HTMLNames.h"
    56 #include "InspectorTimelineAgent.h"
     56#include "InspectorInstrumentation.h"
    5757#include "KeyboardEvent.h"
    5858#include "LabelsNodeList.h"
    … …  
    25782578}
    25792579
    2580 static bool eventHasListeners(const AtomicString& eventType, DOMWindow* window, Node* node, Vector<RefPtr<ContainerNode> >& ancestors)
    2581 {
    2582     if (window && window->hasEventListeners(eventType))
    2583         return true;
    2584 
    2585     if (node->hasEventListeners(eventType))
    2586         return true;
    2587 
    2588     for (size_t i = 0; i < ancestors.size(); i++) {
    2589         ContainerNode* ancestor = ancestors[i].get();
    2590         if (ancestor->hasEventListeners(eventType))
    2591             return true;
    2592     }
    2593 
    2594    return false;   
    2595 }
    2596 
    25972580bool Node::dispatchGenericEvent(PassRefPtr<Event> prpEvent)
    25982581{
    … …  
    26202603    }
    26212604
    2622 #if ENABLE(INSPECTOR)
    2623     Page* inspectedPage = InspectorTimelineAgent::instanceCount() ? document()->page() : 0;
    2624     if (inspectedPage) {
    2625         if (InspectorTimelineAgent* timelineAgent = eventHasListeners(event->type(), targetForWindowEvents, this, ancestors) ? inspectedPage->inspectorTimelineAgent() : 0)
    2626             timelineAgent->willDispatchEvent(*event);
    2627         else
    2628             inspectedPage = 0;
    2629     }
    2630 #endif
     2605    int instrumentationCookie = InspectorInstrumentation::instrumentWillDispatchEvent(document(), *event, targetForWindowEvents, this, ancestors);
    26312606
    26322607    // Give the target node a chance to do some work before DOM event handlers get a crack.
    … …  
    27102685
    27112686doneWithDefault:
    2712 #if ENABLE(INSPECTOR)
    2713     if (inspectedPage)
    2714         if (InspectorTimelineAgent* timelineAgent = inspectedPage->inspectorTimelineAgent())
    2715             timelineAgent->didDispatchEvent();
    2716 #endif
     2687
     2688    InspectorInstrumentation::instrumentDidDispatchEvent(document(), instrumentationCookie);
    27172689
    27182690    return !event->defaultPrevented();

  • trunk/WebCore/inspector/InspectorController.cpp

    r68781 r69014  
    133133static const char* const inspectorAttachedHeightName = "inspectorAttachedHeight";
    134134
     135static const char* const xhrNativeBreakpointType = "XHR";
     136static const char* const eventListenerNativeBreakpointType = "EventListener";
     137
    135138const char* const InspectorController::ElementsPanel = "elements";
    136139const char* const InspectorController::ConsolePanel = "console";
    … …  
    779782        m_times.clear();
    780783        m_counts.clear();
     784
    781785#if ENABLE(JAVASCRIPT_DEBUGGER)
    782786        if (m_debuggerAgent)
    783787            m_debuggerAgent->clearForPageNavigation();
    784788
     789        m_nativeBreakpoints.clear();
     790        m_eventListenerBreakpoints.clear();
     791        m_eventNameToBreakpointCount.clear();
    785792        m_XHRBreakpoints.clear();
    786 #endif
     793        m_lastBreakpointId = 0;
     794#endif
     795
    787796#if ENABLE(JAVASCRIPT_DEBUGGER) && USE(JSC)
    788797        m_profilerAgent->resetState();
    789798#endif
     799
    790800        // unbindAllResources should be called before database and DOM storage
    791801        // resources are cleared so that it has a chance to unbind them.
    … …  
    16761686    if (!breakpoint->getString("type", &type))
    16771687        return;
    1678     if (type == "XHR") {
    1679         RefPtr<InspectorObject> condition = breakpoint->getObject("condition");
    1680         if (!condition)
    1681             return;
     1688    RefPtr<InspectorObject> condition = breakpoint->getObject("condition");
     1689    if (!condition)
     1690        return;
     1691    if (type == xhrNativeBreakpointType) {
    16821692        String url;
    16831693        if (!condition->getString("url", &url))
    16841694            return;
    16851695        *breakpointId = ++m_lastBreakpointId;
     1696        m_nativeBreakpoints.set(*breakpointId, "XHR");
    16861697        m_XHRBreakpoints.set(*breakpointId, url);
     1698    } else if (type == eventListenerNativeBreakpointType) {
     1699        String eventName;
     1700        if (!condition->getString("eventName", &eventName))
     1701            return;
     1702        *breakpointId = ++m_lastBreakpointId;
     1703        m_nativeBreakpoints.set(*breakpointId, "EventListener");
     1704        m_eventListenerBreakpoints.set(*breakpointId, eventName);
     1705        HashMap<String, unsigned int>::iterator it = m_eventNameToBreakpointCount.find(eventName);
     1706        if (it == m_eventNameToBreakpointCount.end())
     1707            m_eventNameToBreakpointCount.set(eventName, 1);
     1708        else
     1709            it->second += 1;
    16871710    }
    16881711}
    … …  
    16901713void InspectorController::removeNativeBreakpoint(unsigned int breakpointId)
    16911714{
    1692     m_XHRBreakpoints.remove(breakpointId);
     1715    String type = m_nativeBreakpoints.take(breakpointId);
     1716    if (type == xhrNativeBreakpointType)
     1717        m_XHRBreakpoints.remove(breakpointId);
     1718    else if (type == eventListenerNativeBreakpointType) {
     1719        String eventName = m_eventListenerBreakpoints.take(breakpointId);
     1720        HashMap<String, unsigned int>::iterator it = m_eventNameToBreakpointCount.find(eventName);
     1721        it->second -= 1;
     1722        if (!it->second)
     1723            m_eventNameToBreakpointCount.remove(it);
     1724    }
     1725}
     1726
     1727bool InspectorController::shouldBreakOnEvent(const String& eventName)
     1728{
     1729    return m_eventNameToBreakpointCount.contains(eventName);
     1730}
     1731
     1732bool InspectorController::shouldBreakOnXMLHttpRequest(const String& url)
     1733{
     1734    for (HashMap<unsigned int, String>::iterator it = m_XHRBreakpoints.begin(); it != m_XHRBreakpoints.end(); ++it) {
     1735        if (url.contains(it->second))
     1736            return true;
     1737    }
     1738    return false;
    16931739}
    16941740
    … …  
    21012147}
    21022148
    2103 void InspectorController::instrumentWillSendXMLHttpRequest(const KURL& url)
    2104 {
    2105 #if ENABLE(JAVASCRIPT_DEBUGGER)
    2106     if (m_debuggerAgent) {
    2107         if (!m_XHRBreakpoints.size())
    2108             return;
    2109         for (HashMap<unsigned int, String>::iterator it = m_XHRBreakpoints.begin(); it != m_XHRBreakpoints.end(); ++it) {
    2110             if (!url.string().contains(it->second))
    2111                 continue;
    2112             RefPtr<InspectorObject> eventData = InspectorObject::create();
    2113             eventData->setString("type", "XHR");
    2114             eventData->setString("url", url);
    2115             m_debuggerAgent->breakProgram(NativeBreakpointDebuggerEventType, eventData);
    2116             break;
    2117         }
    2118     }
    2119 #endif
    2120 }
    2121 
    2122 
    21232149} // namespace WebCore
    21242150

  • trunk/WebCore/inspector/InspectorController.h

    r68767 r69014  
    262262    void setNativeBreakpoint(PassRefPtr<InspectorObject> breakpoint, unsigned int* breakpointId);
    263263    void removeNativeBreakpoint(unsigned int breakpointId);
    264 
    265264#endif
    266265
    … …  
    299298
    300299#if ENABLE(JAVASCRIPT_DEBUGGER)
    301 
    302300    void toggleRecordButton(bool);
    303301    void enableDebuggerFromFrontend(bool always);
     302
     303    bool shouldBreakOnEvent(const String& eventName);
     304    bool shouldBreakOnXMLHttpRequest(const String&);
    304305#endif
    305306#if ENABLE(DATABASE)
    … …  
    329330
    330331    void didEvaluateForTestInFrontend(long callId, const String& jsonResult);
    331 
    332     void instrumentWillSendXMLHttpRequest(const KURL&);
    333332
    334333#if ENABLE(JAVASCRIPT_DEBUGGER)
    … …  
    393392    OwnPtr<InspectorDebuggerAgent> m_debuggerAgent;
    394393
     394    HashMap<unsigned int, String> m_nativeBreakpoints;
     395    HashMap<unsigned int, String> m_eventListenerBreakpoints;
     396    HashMap<String, unsigned int> m_eventNameToBreakpointCount;
    395397    HashMap<unsigned int, String> m_XHRBreakpoints;
    396398    unsigned int m_lastBreakpointId;

  • trunk/WebCore/inspector/InspectorDebuggerAgent.cpp

    r68635 r69014  
    5858}
    5959
    60 InspectorDebuggerAgent* InspectorDebuggerAgent::s_debuggerAgentOnBreakpoint = 0;
    61 
    6260InspectorDebuggerAgent::InspectorDebuggerAgent(InspectorController* inspectorController, InspectorFrontend* frontend)
    6361    : m_inspectorController(inspectorController)
    … …  
    7270    ScriptDebugServer::shared().removeListener(this, m_inspectorController->inspectedPage());
    7371    m_pausedScriptState = 0;
    74 
    75     if (this == s_debuggerAgentOnBreakpoint)
    76         s_debuggerAgentOnBreakpoint = 0;
    7772}
    7873
    … …  
    148143}
    149144
     145void InspectorDebuggerAgent::schedulePauseOnNextStatement(DebuggerEventType type, PassRefPtr<InspectorValue> data)
     146{
     147    m_breakProgramDetails = InspectorObject::create();
     148    m_breakProgramDetails->setNumber("eventType", type);
     149    m_breakProgramDetails->setValue("eventData", data);
     150    ScriptDebugServer::shared().setPauseOnNextStatement(true);
     151}
     152
     153void InspectorDebuggerAgent::cancelPauseOnNextStatement()
     154{
     155    m_breakProgramDetails = 0;
     156    ScriptDebugServer::shared().setPauseOnNextStatement(false);
     157}
     158
    150159void InspectorDebuggerAgent::pause()
    151160{
    152     ScriptDebugServer::shared().pause();
     161    schedulePauseOnNextStatement(JavaScriptPauseEventType, InspectorObject::create());
    153162}
    154163
    … …  
    306315{
    307316    m_pausedScriptState = 0;
     317    m_breakProgramDetails = 0;
    308318    m_frontend->resumedScript();
    309319}
    … …  
    314324    m_breakProgramDetails->setNumber("eventType", type);
    315325    m_breakProgramDetails->setValue("eventData", data);
    316     s_debuggerAgentOnBreakpoint = this;
    317 
    318326    ScriptDebugServer::shared().breakProgram();
    319     if (!s_debuggerAgentOnBreakpoint)
    320         return;
    321 
    322     s_debuggerAgentOnBreakpoint = 0;
    323     m_breakProgramDetails = 0;
    324327}
    325328

  • trunk/WebCore/inspector/InspectorDebuggerAgent.h

    r68635 r69014  
    4848
    4949enum DebuggerEventType {
     50    JavaScriptPauseEventType,
    5051    DOMBreakpointDebuggerEventType,
    5152    NativeBreakpointDebuggerEventType
    … …  
    6768    void getScriptSource(const String& sourceID, String* scriptSource);
    6869
     70    void schedulePauseOnNextStatement(DebuggerEventType type, PassRefPtr<InspectorValue> data);
     71    void cancelPauseOnNextStatement();
     72    void breakProgram(DebuggerEventType type, PassRefPtr<InspectorValue> data);
    6973    void pause();
    70     void breakProgram(DebuggerEventType type, PassRefPtr<InspectorValue> data);
    7174    void resume();
    7275    void stepOverStatement();

  • trunk/WebCore/inspector/InspectorInstrumentation.cpp

    r68767 r69014  
    3434#if ENABLE(INSPECTOR)
    3535
     36#include "DOMWindow.h"
     37#include "Event.h"
    3638#include "InspectorController.h"
    3739#include "InspectorDOMAgent.h"
    3840#include "InspectorDebuggerAgent.h"
     41#include "InspectorTimelineAgent.h"
    3942
    4043namespace WebCore {
    4144
    4245int InspectorInstrumentation::s_frontendCounter = 0;
     46
     47static bool eventHasListeners(const AtomicString& eventType, DOMWindow* window, Node* node, const Vector<RefPtr<ContainerNode> >& ancestors)
     48{
     49    if (window && window->hasEventListeners(eventType))
     50        return true;
     51
     52    if (node->hasEventListeners(eventType))
     53        return true;
     54
     55    for (size_t i = 0; i < ancestors.size(); i++) {
     56        ContainerNode* ancestor = ancestors[i].get();
     57        if (ancestor->hasEventListeners(eventType))
     58            return true;
     59    }
     60
     61    return false;
     62}
    4363
    4464void InspectorInstrumentation::willInsertDOMNodeImpl(InspectorController* inspectorController, Node* node, Node* parent)
    … …  
    125145}
    126146
    127 void InspectorInstrumentation::instrumentWillSendXMLHttpRequestImpl(InspectorController* inspectorController, const KURL& url)
    128 {
    129     if (!inspectorController->hasFrontend())
    130         return;
    131     inspectorController->instrumentWillSendXMLHttpRequest(url);
     147int InspectorInstrumentation::instrumentWillDispatchEventImpl(InspectorController* inspectorController, const Event& event, DOMWindow* window, Node* node, const Vector<RefPtr<ContainerNode> >& ancestors)
     148{
     149    int instrumentationCookie = 0;
     150
     151    if (!inspectorController->hasFrontend())
     152        return instrumentationCookie;
     153
     154#if ENABLE(JAVASCRIPT_DEBUGGER)
     155    if (InspectorDebuggerAgent* debuggerAgent = inspectorController->m_debuggerAgent.get()) {
     156        if (inspectorController->shouldBreakOnEvent(event.type())) {
     157            RefPtr<InspectorObject> eventData = InspectorObject::create();
     158            eventData->setString("type", "EventListener");
     159            eventData->setString("eventName", event.type());
     160            debuggerAgent->schedulePauseOnNextStatement(NativeBreakpointDebuggerEventType, eventData);
     161        }
     162    }
     163#endif
     164
     165    InspectorTimelineAgent* timelineAgent = inspectorController->m_timelineAgent.get();
     166    if (timelineAgent && eventHasListeners(event.type(), window, node, ancestors)) {
     167        timelineAgent->willDispatchEvent(event);
     168        instrumentationCookie = timelineAgent->id();
     169    }
     170    return instrumentationCookie;
     171}
     172
     173void InspectorInstrumentation::instrumentDidDispatchEventImpl(InspectorController* inspectorController, int instrumentationCookie)
     174{
     175    if (!inspectorController->hasFrontend())
     176        return;
     177
     178#if ENABLE(JAVASCRIPT_DEBUGGER)
     179    if (InspectorDebuggerAgent* debuggerAgent = inspectorController->m_debuggerAgent.get())
     180        debuggerAgent->cancelPauseOnNextStatement();
     181#endif
     182
     183    InspectorTimelineAgent* timelineAgent = inspectorController->m_timelineAgent.get();
     184    if (timelineAgent && timelineAgent->id() == instrumentationCookie)
     185        timelineAgent->didDispatchEvent();
     186}
     187
     188void InspectorInstrumentation::instrumentWillSendXMLHttpRequestImpl(InspectorController* inspectorController, const String& url)
     189{
     190#if ENABLE(JAVASCRIPT_DEBUGGER)
     191    if (!inspectorController->hasFrontend())
     192        return;
     193
     194    InspectorDebuggerAgent* debuggerAgent = inspectorController->m_debuggerAgent.get();
     195    if (!debuggerAgent)
     196        return;
     197
     198    if (!inspectorController->shouldBreakOnXMLHttpRequest(url))
     199        return;
     200
     201    RefPtr<InspectorObject> eventData = InspectorObject::create();
     202    eventData->setString("type", "XHR");
     203    eventData->setString("url", url);
     204    debuggerAgent->breakProgram(NativeBreakpointDebuggerEventType, eventData);
     205#endif
    132206}
    133207

  • trunk/WebCore/inspector/InspectorInstrumentation.h

    r68767 r69014  
    4141class Element;
    4242class InspectorController;
    43 class KURL;
    4443class Node;
    4544
    … …  
    5352    static void characterDataModified(Document*, CharacterData*);
    5453
    55     static void instrumentWillSendXMLHttpRequest(ScriptExecutionContext*, const KURL&);
     54    static int instrumentWillDispatchEvent(Document*, const Event&, DOMWindow*, Node*, const Vector<RefPtr<ContainerNode> >& ancestors);
     55    static void instrumentDidDispatchEvent(Document*, int instrumentationCookie);
     56
     57    static void instrumentWillSendXMLHttpRequest(ScriptExecutionContext*, const String&);
    5658
    5759#if ENABLE(INSPECTOR)
    … …  
    7173    static void characterDataModifiedImpl(InspectorController*, CharacterData*);
    7274
    73     static void instrumentWillSendXMLHttpRequestImpl(InspectorController*, const KURL&);
     75    static int instrumentWillDispatchEventImpl(InspectorController*, const Event&, DOMWindow*, Node*, const Vector<RefPtr<ContainerNode> >& ancestors);
     76    static void instrumentDidDispatchEventImpl(InspectorController*, int instrumentationCookie);
     77
     78    static void instrumentWillSendXMLHttpRequestImpl(InspectorController*, const String&);
    7479
    7580    static InspectorController* inspectorControllerForScriptExecutionContext(ScriptExecutionContext*);
    … …  
    131136}
    132137
    133 inline void InspectorInstrumentation::instrumentWillSendXMLHttpRequest(ScriptExecutionContext* context, const KURL& url)
     138inline int InspectorInstrumentation::instrumentWillDispatchEvent(Document* document, const Event& event, DOMWindow* window, Node* node, const Vector<RefPtr<ContainerNode> >& ancestors)
     139{
     140#if ENABLE(INSPECTOR)
     141    if (InspectorController* inspectorController = inspectorControllerForDocument(document))
     142        return instrumentWillDispatchEventImpl(inspectorController, event, window, node, ancestors);
     143#endif
     144    return 0;
     145}
     146
     147inline void InspectorInstrumentation::instrumentDidDispatchEvent(Document* document, int instrumentationCookie)
     148{
     149#if ENABLE(INSPECTOR)
     150    if (InspectorController* inspectorController = inspectorControllerForDocument(document))
     151        instrumentDidDispatchEventImpl(inspectorController, instrumentationCookie);
     152#endif
     153}
     154
     155inline void InspectorInstrumentation::instrumentWillSendXMLHttpRequest(ScriptExecutionContext* context, const String& url)
    134156{
    135157#if ENABLE(INSPECTOR)

  • trunk/WebCore/inspector/InspectorTimelineAgent.cpp

    r68779 r69014  
    4646
    4747int InspectorTimelineAgent::s_instanceCount = 0;
     48int InspectorTimelineAgent::s_id = 0;
    4849
    4950InspectorTimelineAgent::InspectorTimelineAgent(InspectorFrontend* frontend)
    5051    : m_frontend(frontend)
     52    , m_id(++s_id)
    5153{
    5254    ++s_instanceCount;

  • trunk/WebCore/inspector/InspectorTimelineAgent.h

    r68779 r69014  
    7777    InspectorTimelineAgent(InspectorFrontend* frontend);
    7878    ~InspectorTimelineAgent();
     79
     80    int id() const { return m_id; }
    7981
    8082    void reset();
    … …  
    157159    Vector<TimelineRecordEntry> m_recordStack;
    158160    static int s_instanceCount;
     161    static int s_id;
     162    const int m_id;
    159163    struct GCEvent {
    160164        GCEvent(double startTime, double endTime, size_t collectedBytes)

  • trunk/WebCore/inspector/front-end/CallStackSidebarPane.js

    r68395 r69014  
    3030
    3131WebInspector.CallStackSidebarPane.DebuggerEventType = {
    32     DOMBreakpoint: 0,
    33     NativeBreakpoint: 1
     32    JavaScriptPause: 0,
     33    DOMBreakpoint: 1,
     34    NativeBreakpoint: 2
    3435};
    3536
Note: See TracChangeset for help on using the changeset viewer.