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
 170 InspectorController::~InspectorController()
 171 {
 172     for (Agents::iterator it = m_agents.begin(); it != m_agents.end(); ++it)
 173         (*it)->discardAgent();
 174
 175     ASSERT(!m_inspectorClient);
 176 }
 177
 178 PassOwnPtr<InspectorController> InspectorController::create(Page* page, InspectorClient* client)
 179 {
 180     return adoptPtr(new InspectorController(page, client));
 181 }
 182
 183 void InspectorController::inspectedPageDestroyed()
 184 {
 185     disconnectFrontend();
 186     m_injectedScriptManager->disconnect();
 187     m_inspectorClient->inspectorDestroyed();
 188     m_inspectorClient = 0;
 189     m_page = 0;
 190 }
 191
 192 void InspectorController::setInspectorFrontendClient(PassOwnPtr<InspectorFrontendClient> inspectorFrontendClient)
 193 {
 194     m_inspectorFrontendClient = inspectorFrontendClient;
 195 }
 196
 197 bool InspectorController::hasInspectorFrontendClient() const
 198 {
 199     return m_inspectorFrontendClient;
 200 }
 201
 202 void InspectorController::didClearWindowObjectInWorld(Frame* frame, DOMWrapperWorld* world)
 203 {
 204     if (world != mainThreadNormalWorld())
 205         return;
 206
 207     // If the page is supposed to serve as InspectorFrontend notify inspector frontend
 208     // client that it's cleared so that the client can expose inspector bindings.
 209     if (m_inspectorFrontendClient && frame == m_page->mainFrame())
 210         m_inspectorFrontendClient->windowObjectCleared();
 211 }
 212
 213 void InspectorController::connectFrontend(InspectorFrontendChannel* frontendChannel)
 214 {
 215     ASSERT(frontendChannel);
 216
 217     m_inspectorFrontend = adoptPtr(new InspectorFrontend(frontendChannel));
 218     // We can reconnect to existing front-end -> unmute state.
 219     m_state->unmute();
 220
 221     InspectorFrontend* frontend = m_inspectorFrontend.get();
 222     for (Agents::iterator it = m_agents.begin(); it != m_agents.end(); ++it)
 223         (*it)->setFrontend(frontend);
 224
 225     if (!InspectorInstrumentation::hasFrontends())
 226         ScriptController::setCaptureCallStackForUncaughtExceptions(true);
 227     InspectorInstrumentation::frontendCreated();
 228
 229     ASSERT(m_inspectorClient);
 230     m_inspectorBackendDispatcher = InspectorBackendDispatcher::create(frontendChannel);
 231
 232     InspectorBackendDispatcher* dispatcher = m_inspectorBackendDispatcher.get();
 233     for (Agents::iterator it = m_agents.begin(); it != m_agents.end(); ++it)
 234         (*it)->registerInDispatcher(dispatcher);
 235 }
 236
 237 void InspectorController::disconnectFrontend()
 238 {
 239     if (!m_inspectorFrontend)
 240         return;
 241     m_inspectorBackendDispatcher->clearFrontend();
 242     m_inspectorBackendDispatcher.clear();
 243
 244     // Destroying agents would change the state, but we don't want that.
 245     // Pre-disconnect state will be used to restore inspector agents.
 246     m_state->mute();
 247
 248     for (Agents::iterator it = m_agents.begin(); it != m_agents.end(); ++it)
 249         (*it)->clearFrontend();
 250
 251     m_inspectorFrontend.clear();
 252
 253     InspectorInstrumentation::frontendDeleted();
 254     if (!InspectorInstrumentation::hasFrontends())
 255         ScriptController::setCaptureCallStackForUncaughtExceptions(false);
 256 }
 257
 258 void InspectorController::show()
 259 {
 260     if (!enabled())
 261         return;
 262
 263     if (m_inspectorFrontend)
 264         m_inspectorClient->bringFrontendToFront();
 265     else {
 266         InspectorFrontendChannel* frontendChannel = m_inspectorClient->openInspectorFrontend(this);
 267         if (frontendChannel)
 268             connectFrontend(frontendChannel);
 269     }
 270 }
 271
 272 void InspectorController::close()
 273 {
 274     if (!m_inspectorFrontend)
 275         return;
 276     disconnectFrontend();
 277     m_inspectorClient->closeInspectorFrontend();
 278 }
 279
 280 void InspectorController::reconnectFrontend(InspectorFrontendChannel* frontendChannel, const String& inspectorStateCookie)
 281 {
 282     ASSERT(!m_inspectorFrontend);
 283     connectFrontend(frontendChannel);
 284     m_state->loadFromCookie(inspectorStateCookie);
 285
 286     for (Agents::iterator it = m_agents.begin(); it != m_agents.end(); ++it)
 287         (*it)->restore();
 288 }
 289
 290 void InspectorController::setProcessId(long processId)
 291 {
 292     IdentifiersFactory::setProcessId(processId);
 293 }
 294
 295 void InspectorController::evaluateForTestInFrontend(long callId, const String& script)
 296 {
 297     m_inspectorAgent->evaluateForTestInFrontend(callId, script);
 298 }
 299
 300 void InspectorController::drawHighlight(GraphicsContext& context) const
 301 {
 302     m_overlay->paint(context);
 303 }
 304
 305 void InspectorController::getHighlight(Highlight* highlight) const
 306 {
 307     m_overlay->getHighlight(highlight);
 308 }
 309
 310 void InspectorController::inspect(Node* node)
 311 {
 312     if (!enabled())
 313         return;
 314
 315     show();
 316
 317     m_domAgent->inspect(node);
 318 }
 319
 320 bool InspectorController::enabled() const
 321 {
 322     return m_inspectorAgent->developerExtrasEnabled();
 323 }
 324
 325 Page* InspectorController::inspectedPage() const
 326 {
 327     return m_page;
 328 }
 329
 330 void InspectorController::setInjectedScriptForOrigin(const String& origin, const String& source)
 331 {
 332     m_inspectorAgent->setInjectedScriptForOrigin(origin, source);
 333 }
 334
 335 void InspectorController::dispatchMessageFromFrontend(const String& message)
 336 {
 337     if (m_inspectorBackendDispatcher)
 338         m_inspectorBackendDispatcher->dispatch(message);
 339 }
 340
 341 void InspectorController::hideHighlight()
 342 {
 343     ErrorString error;
 344     m_domAgent->hideHighlight(&error);
 345 }
 346
 347 Node* InspectorController::highlightedNode() const
 348 {
 349     return m_overlay->highlightedNode();
 350 }
 351
 352 #if ENABLE(JAVASCRIPT_DEBUGGER)
 353 bool InspectorController::profilerEnabled()
 354 {
 355     return m_profilerAgent->enabled();
 356 }
 357
 358 void InspectorController::setProfilerEnabled(bool enable)
 359 {
 360     ErrorString error;
 361     if (enable)
 362         m_profilerAgent->enable(&error);
 363     else
 364         m_profilerAgent->disable(&error);
 365 }
 366
 367 void InspectorController::resume()
 368 {
 369     if (m_debuggerAgent) {
 370         ErrorString error;
 371         m_debuggerAgent->resume(&error);
 372     }
 373 }
 374 #endif
 375
 376 void InspectorController::setResourcesDataSizeLimitsFromInternals(int maximumResourcesContentSize, int maximumSingleResourceContentSize)
 377 {
 378     m_resourceAgent->setResourcesDataSizeLimitsFromInternals(maximumResourcesContentSize, maximumSingleResourceContentSize);
 379 }
 380
 381 } // namespace WebCore
 382
 383 #endif // ENABLE(INSPECTOR)