ab6e377c15caf85041a80d5e3450636703f05c5b
[WebKit-https.git] / Source / WebCore / inspector / InspectorController.cpp
1 /*
2  * Copyright (C) 2011 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
33 #if ENABLE(INSPECTOR)
34
35 #include "InspectorController.h"
36
37 #include "DOMNodeHighlighter.h"
38 #include "Frame.h"
39 #include "GraphicsContext.h"
40 #include "IdentifiersFactory.h"
41 #include "InjectedScriptHost.h"
42 #include "InjectedScriptManager.h"
43 #include "InspectorAgent.h"
44 #include "InspectorApplicationCacheAgent.h"
45 #include "InspectorBackendDispatcher.h"
46 #include "InspectorBaseAgent.h"
47 #include "InspectorCSSAgent.h"
48 #include "InspectorClient.h"
49 #include "InspectorDOMAgent.h"
50 #include "InspectorDOMDebuggerAgent.h"
51 #include "InspectorDOMStorageAgent.h"
52 #include "InspectorDatabaseAgent.h"
53 #include "InspectorDebuggerAgent.h"
54 #include "InspectorFileSystemAgent.h"
55 #include "InspectorFrontend.h"
56 #include "InspectorFrontendClient.h"
57 #include "InspectorIndexedDBAgent.h"
58 #include "InspectorInstrumentation.h"
59 #include "InspectorMemoryAgent.h"
60 #include "InspectorPageAgent.h"
61 #include "InspectorProfilerAgent.h"
62 #include "InspectorResourceAgent.h"
63 #include "InspectorState.h"
64 #include "InspectorTimelineAgent.h"
65 #include "InspectorWebGLAgent.h"
66 #include "InspectorWorkerAgent.h"
67 #include "InstrumentingAgents.h"
68 #include "PageConsoleAgent.h"
69 #include "PageDebuggerAgent.h"
70 #include "PageRuntimeAgent.h"
71 #include "Page.h"
72 #include "ScriptObject.h"
73 #include "Settings.h"
74 #include <wtf/UnusedParam.h>
75
76 namespace WebCore {
77
78 InspectorController::InspectorController(Page* page, InspectorClient* inspectorClient)
79     : m_instrumentingAgents(adoptPtr(new InstrumentingAgents()))
80     , m_injectedScriptManager(InjectedScriptManager::createForPage())
81     , m_state(adoptPtr(new InspectorState(inspectorClient)))
82     , m_overlay(InspectorOverlay::create(page, inspectorClient))
83     , m_page(page)
84     , m_inspectorClient(inspectorClient)
85 {
86     OwnPtr<InspectorAgent> inspectorAgentPtr(InspectorAgent::create(page, m_injectedScriptManager.get(), m_instrumentingAgents.get(), m_state.get()));
87     m_inspectorAgent = inspectorAgentPtr.get();
88     m_agents.append(inspectorAgentPtr.release());
89
90     OwnPtr<InspectorPageAgent> pageAgentPtr(InspectorPageAgent::create(m_instrumentingAgents.get(), page, m_inspectorAgent, m_state.get(), m_injectedScriptManager.get(), inspectorClient, m_overlay.get()));
91     InspectorPageAgent* pageAgent = pageAgentPtr.get();
92     m_pageAgent = pageAgentPtr.get();
93     m_agents.append(pageAgentPtr.release());
94
95     OwnPtr<InspectorDOMAgent> domAgentPtr(InspectorDOMAgent::create(m_instrumentingAgents.get(), pageAgent, m_state.get(), m_injectedScriptManager.get(), m_overlay.get()));
96     m_domAgent = domAgentPtr.get();
97     m_agents.append(domAgentPtr.release());
98
99     m_agents.append(InspectorCSSAgent::create(m_instrumentingAgents.get(), m_state.get(), m_domAgent));
100
101 #if ENABLE(SQL_DATABASE)
102     OwnPtr<InspectorDatabaseAgent> databaseAgentPtr(InspectorDatabaseAgent::create(m_instrumentingAgents.get(), m_state.get()));
103     InspectorDatabaseAgent* databaseAgent = databaseAgentPtr.get();
104     m_agents.append(databaseAgentPtr.release());
105 #endif
106
107 #if ENABLE(INDEXED_DATABASE)
108     m_agents.append(InspectorIndexedDBAgent::create(m_instrumentingAgents.get(), m_state.get(), m_injectedScriptManager.get(), pageAgent));
109 #endif
110
111 #if ENABLE(FILE_SYSTEM)
112     m_agents.append(InspectorFileSystemAgent::create(m_instrumentingAgents.get(), pageAgent, m_state.get()));
113 #endif
114     OwnPtr<InspectorDOMStorageAgent> domStorageAgentPtr(InspectorDOMStorageAgent::create(m_instrumentingAgents.get(), m_state.get()));
115     InspectorDOMStorageAgent* domStorageAgent = domStorageAgentPtr.get();
116     m_agents.append(domStorageAgentPtr.release());
117     m_agents.append(InspectorMemoryAgent::create(m_instrumentingAgents.get(), m_state.get(), m_page, m_domAgent));
118     m_agents.append(InspectorTimelineAgent::create(m_instrumentingAgents.get(), pageAgent, m_state.get(), InspectorTimelineAgent::PageInspector,
119        inspectorClient));
120     m_agents.append(InspectorApplicationCacheAgent::create(m_instrumentingAgents.get(), m_state.get(), pageAgent));
121
122     OwnPtr<InspectorResourceAgent> resourceAgentPtr(InspectorResourceAgent::create(m_instrumentingAgents.get(), pageAgent, inspectorClient, m_state.get()));
123     m_resourceAgent = resourceAgentPtr.get();
124     m_agents.append(resourceAgentPtr.release());
125
126     OwnPtr<InspectorRuntimeAgent> runtimeAgentPtr(PageRuntimeAgent::create(m_instrumentingAgents.get(), m_state.get(), m_injectedScriptManager.get(), page, pageAgent, m_inspectorAgent));
127     InspectorRuntimeAgent* runtimeAgent = runtimeAgentPtr.get();
128     m_agents.append(runtimeAgentPtr.release());
129
130     OwnPtr<InspectorConsoleAgent> consoleAgentPtr(PageConsoleAgent::create(m_instrumentingAgents.get(), m_inspectorAgent, m_state.get(), m_injectedScriptManager.get(), m_domAgent));
131     InspectorConsoleAgent* consoleAgent = consoleAgentPtr.get();
132     m_agents.append(consoleAgentPtr.release());
133
134 #if ENABLE(JAVASCRIPT_DEBUGGER)
135     OwnPtr<InspectorDebuggerAgent> debuggerAgentPtr(PageDebuggerAgent::create(m_instrumentingAgents.get(), m_state.get(), page, m_injectedScriptManager.get(), m_overlay.get()));
136     m_debuggerAgent = debuggerAgentPtr.get();
137     m_agents.append(debuggerAgentPtr.release());
138
139     m_agents.append(InspectorDOMDebuggerAgent::create(m_instrumentingAgents.get(), m_state.get(), m_domAgent, m_debuggerAgent, m_inspectorAgent));
140
141     OwnPtr<InspectorProfilerAgent> profilerAgentPtr(InspectorProfilerAgent::create(m_instrumentingAgents.get(), consoleAgent, page, m_state.get(), m_injectedScriptManager.get()));
142     m_profilerAgent = profilerAgentPtr.get();
143     m_agents.append(profilerAgentPtr.release());
144 #endif
145
146 #if ENABLE(WORKERS)
147     m_agents.append(InspectorWorkerAgent::create(m_instrumentingAgents.get(), m_state.get()));
148 #endif
149
150 #if ENABLE(WEBGL)
151     m_agents.append(InspectorWebGLAgent::create(m_instrumentingAgents.get(), m_state.get(), m_injectedScriptManager.get()));
152 #endif
153
154     ASSERT_ARG(inspectorClient, inspectorClient);
155     m_injectedScriptManager->injectedScriptHost()->init(m_inspectorAgent
156         , consoleAgent
157 #if ENABLE(SQL_DATABASE)
158         , databaseAgent
159 #endif
160         , domStorageAgent
161         , m_domAgent
162         , m_debuggerAgent
163     );
164
165 #if ENABLE(JAVASCRIPT_DEBUGGER)
166     runtimeAgent->setScriptDebugServer(&m_debuggerAgent->scriptDebugServer());
167 #endif
168
169     InspectorInstrumentation::registerInstrumentingAgents(m_instrumentingAgents.get());
170 }
171
172 InspectorController::~InspectorController()
173 {
174     for (Agents::iterator it = m_agents.begin(); it != m_agents.end(); ++it)
175         (*it)->discardAgent();
176
177     ASSERT(!m_inspectorClient);
178 }
179
180 PassOwnPtr<InspectorController> InspectorController::create(Page* page, InspectorClient* client)
181 {
182     return adoptPtr(new InspectorController(page, client));
183 }
184
185 void InspectorController::inspectedPageDestroyed()
186 {
187     disconnectFrontend();
188     InspectorInstrumentation::unregisterInstrumentingAgents(m_instrumentingAgents.get());
189     m_injectedScriptManager->disconnect();
190     m_inspectorClient->inspectorDestroyed();
191     m_inspectorClient = 0;
192     m_page = 0;
193 }
194
195 void InspectorController::setInspectorFrontendClient(PassOwnPtr<InspectorFrontendClient> inspectorFrontendClient)
196 {
197     m_inspectorFrontendClient = inspectorFrontendClient;
198 }
199
200 bool InspectorController::hasInspectorFrontendClient() const
201 {
202     return m_inspectorFrontendClient;
203 }
204
205 void InspectorController::didClearWindowObjectInWorld(Frame* frame, DOMWrapperWorld* world)
206 {
207     if (world != mainThreadNormalWorld())
208         return;
209
210     // If the page is supposed to serve as InspectorFrontend notify inspector frontend
211     // client that it's cleared so that the client can expose inspector bindings.
212     if (m_inspectorFrontendClient && frame == m_page->mainFrame())
213         m_inspectorFrontendClient->windowObjectCleared();
214 }
215
216 void InspectorController::connectFrontend(InspectorFrontendChannel* frontendChannel)
217 {
218     ASSERT(frontendChannel);
219
220     m_inspectorFrontend = adoptPtr(new InspectorFrontend(frontendChannel));
221     // We can reconnect to existing front-end -> unmute state.
222     m_state->unmute();
223
224     InspectorFrontend* frontend = m_inspectorFrontend.get();
225     for (Agents::iterator it = m_agents.begin(); it != m_agents.end(); ++it)
226         (*it)->setFrontend(frontend);
227
228     if (!InspectorInstrumentation::hasFrontends())
229         ScriptController::setCaptureCallStackForUncaughtExceptions(true);
230     InspectorInstrumentation::frontendCreated();
231
232     ASSERT(m_inspectorClient);
233     m_inspectorBackendDispatcher = InspectorBackendDispatcher::create(frontendChannel);
234
235     InspectorBackendDispatcher* dispatcher = m_inspectorBackendDispatcher.get();
236     for (Agents::iterator it = m_agents.begin(); it != m_agents.end(); ++it)
237         (*it)->registerInDispatcher(dispatcher);
238 }
239
240 void InspectorController::disconnectFrontend()
241 {
242     if (!m_inspectorFrontend)
243         return;
244     m_inspectorBackendDispatcher->clearFrontend();
245     m_inspectorBackendDispatcher.clear();
246
247     // Destroying agents would change the state, but we don't want that.
248     // Pre-disconnect state will be used to restore inspector agents.
249     m_state->mute();
250
251     for (Agents::iterator it = m_agents.begin(); it != m_agents.end(); ++it)
252         (*it)->clearFrontend();
253
254     m_inspectorFrontend.clear();
255
256     InspectorInstrumentation::frontendDeleted();
257     if (!InspectorInstrumentation::hasFrontends())
258         ScriptController::setCaptureCallStackForUncaughtExceptions(false);
259 }
260
261 void InspectorController::show()
262 {
263     if (!enabled())
264         return;
265
266     if (m_inspectorFrontend)
267         m_inspectorClient->bringFrontendToFront();
268     else {
269         InspectorFrontendChannel* frontendChannel = m_inspectorClient->openInspectorFrontend(this);
270         if (frontendChannel)
271             connectFrontend(frontendChannel);
272     }
273 }
274
275 void InspectorController::close()
276 {
277     if (!m_inspectorFrontend)
278         return;
279     disconnectFrontend();
280     m_inspectorClient->closeInspectorFrontend();
281 }
282
283 void InspectorController::reconnectFrontend(InspectorFrontendChannel* frontendChannel, const String& inspectorStateCookie)
284 {
285     ASSERT(!m_inspectorFrontend);
286     connectFrontend(frontendChannel);
287     m_state->loadFromCookie(inspectorStateCookie);
288
289     for (Agents::iterator it = m_agents.begin(); it != m_agents.end(); ++it)
290         (*it)->restore();
291 }
292
293 void InspectorController::setProcessId(long processId)
294 {
295     IdentifiersFactory::setProcessId(processId);
296 }
297
298 void InspectorController::evaluateForTestInFrontend(long callId, const String& script)
299 {
300     m_inspectorAgent->evaluateForTestInFrontend(callId, script);
301 }
302
303 void InspectorController::drawHighlight(GraphicsContext& context) const
304 {
305     m_overlay->paint(context);
306 }
307
308 void InspectorController::getHighlight(Highlight* highlight) const
309 {
310     m_overlay->getHighlight(highlight);
311 }
312
313 void InspectorController::inspect(Node* node)
314 {
315     if (!enabled())
316         return;
317
318     show();
319
320     m_domAgent->inspect(node);
321 }
322
323 bool InspectorController::enabled() const
324 {
325     return m_inspectorAgent->developerExtrasEnabled();
326 }
327
328 Page* InspectorController::inspectedPage() const
329 {
330     return m_page;
331 }
332
333 void InspectorController::setInjectedScriptForOrigin(const String& origin, const String& source)
334 {
335     m_inspectorAgent->setInjectedScriptForOrigin(origin, source);
336 }
337
338 void InspectorController::dispatchMessageFromFrontend(const String& message)
339 {
340     if (m_inspectorBackendDispatcher)
341         m_inspectorBackendDispatcher->dispatch(message);
342 }
343
344 void InspectorController::hideHighlight()
345 {
346     ErrorString error;
347     m_domAgent->hideHighlight(&error);
348 }
349
350 Node* InspectorController::highlightedNode() const
351 {
352     return m_overlay->highlightedNode();
353 }
354
355 #if ENABLE(JAVASCRIPT_DEBUGGER)
356 bool InspectorController::profilerEnabled()
357 {
358     return m_profilerAgent->enabled();
359 }
360
361 void InspectorController::setProfilerEnabled(bool enable)
362 {
363     ErrorString error;
364     if (enable)
365         m_profilerAgent->enable(&error);
366     else
367         m_profilerAgent->disable(&error);
368 }
369
370 void InspectorController::resume()
371 {
372     if (m_debuggerAgent) {
373         ErrorString error;
374         m_debuggerAgent->resume(&error);
375     }
376 }
377 #endif
378
379 void InspectorController::setResourcesDataSizeLimitsFromInternals(int maximumResourcesContentSize, int maximumSingleResourceContentSize)
380 {
381     m_resourceAgent->setResourcesDataSizeLimitsFromInternals(maximumResourcesContentSize, maximumSingleResourceContentSize);
382 }
383
384 } // namespace WebCore
385
386 #endif // ENABLE(INSPECTOR)