src/third_party/WebKit/Source/core/inspector/InspectorInstrumentation.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 #include "core/inspector/InspectorInstrumentation.h"
  33
  34 #include "core/events/EventTarget.h"
  35 #include "core/fetch/FetchInitiatorInfo.h"
  36 #include "core/inspector/InspectorCSSAgent.h"
  37 #include "core/inspector/InspectorConsoleAgent.h"
  38 #include "core/inspector/InspectorController.h"
  39 #include "core/inspector/InspectorDebuggerAgent.h"
  40 #include "core/inspector/InspectorInspectorAgent.h"
  41 #include "core/inspector/InspectorProfilerAgent.h"
  42 #include "core/inspector/InspectorResourceAgent.h"
  43 #include "core/inspector/InspectorTimelineAgent.h"
  44 #include "core/inspector/InstrumentingAgents.h"
  45 #include "core/inspector/ScriptAsyncCallStack.h"
  46 #include "core/inspector/ScriptCallStack.h"
  47 #include "core/inspector/WorkerInspectorController.h"
  48 #include "core/page/Page.h"
  49 #include "core/workers/WorkerGlobalScope.h"
  50
  51 namespace blink {
  52
  53 namespace {
  54 static HashSet<InstrumentingAgents*>* instrumentingAgentsSet = 0;
  55 }
  56
  57 namespace InspectorInstrumentation {
  58 int FrontendCounter::s_frontendCounter = 0;
  59 }
  60
  61 InspectorInstrumentationCookie::InspectorInstrumentationCookie()
  62     : m_instrumentingAgents(nullptr)
  63     , m_timelineAgentId(0)
  64 {
  65 }
  66
  67 InspectorInstrumentationCookie::InspectorInstrumentationCookie(InstrumentingAgents* agents, int timelineAgentId)
  68     : m_instrumentingAgents(agents)
  69     , m_timelineAgentId(timelineAgentId)
  70 {
  71 }
  72
  73 InspectorInstrumentationCookie::InspectorInstrumentationCookie(const InspectorInstrumentationCookie& other)
  74     : m_instrumentingAgents(other.m_instrumentingAgents)
  75     , m_timelineAgentId(other.m_timelineAgentId)
  76 {
  77 }
  78
  79 InspectorInstrumentationCookie& InspectorInstrumentationCookie::operator=(const InspectorInstrumentationCookie& other)
  80 {
  81     if (this != &other) {
  82         m_instrumentingAgents = other.m_instrumentingAgents;
  83         m_timelineAgentId = other.m_timelineAgentId;
  84     }
  85     return *this;
  86 }
  87
  88 InspectorInstrumentationCookie::~InspectorInstrumentationCookie()
  89 {
  90 }
  91
  92 namespace InspectorInstrumentation {
  93
  94 bool isDebuggerPausedImpl(InstrumentingAgents* instrumentingAgents)
  95 {
  96     if (InspectorDebuggerAgent* debuggerAgent = instrumentingAgents->inspectorDebuggerAgent())
  97         return debuggerAgent->isPaused();
  98     return false;
  99 }
 100
 101 void didReceiveResourceResponseButCanceledImpl(LocalFrame* frame, DocumentLoader* loader, unsigned long identifier, const ResourceResponse& r)
 102 {
 103     didReceiveResourceResponse(frame, identifier, loader, r, 0);
 104 }
 105
 106 void continueAfterXFrameOptionsDeniedImpl(LocalFrame* frame, DocumentLoader* loader, unsigned long identifier, const ResourceResponse& r)
 107 {
 108     didReceiveResourceResponseButCanceledImpl(frame, loader, identifier, r);
 109 }
 110
 111 void continueWithPolicyIgnoreImpl(LocalFrame* frame, DocumentLoader* loader, unsigned long identifier, const ResourceResponse& r)
 112 {
 113     didReceiveResourceResponseButCanceledImpl(frame, loader, identifier, r);
 114 }
 115
 116 void willDestroyResourceImpl(Resource* cachedResource)
 117 {
 118     if (!instrumentingAgentsSet)
 119         return;
 120     HashSet<InstrumentingAgents*>::iterator end = instrumentingAgentsSet->end();
 121     for (HashSet<InstrumentingAgents*>::iterator it = instrumentingAgentsSet->begin(); it != end; ++it) {
 122         InstrumentingAgents* instrumentingAgents = *it;
 123         if (InspectorResourceAgent* inspectorResourceAgent = instrumentingAgents->inspectorResourceAgent())
 124             inspectorResourceAgent->willDestroyResource(cachedResource);
 125     }
 126 }
 127
 128 bool collectingHTMLParseErrorsImpl(InstrumentingAgents* instrumentingAgents)
 129 {
 130     if (InspectorInspectorAgent* inspectorAgent = instrumentingAgents->inspectorInspectorAgent())
 131         return inspectorAgent->hasFrontend();
 132     return false;
 133 }
 134
 135 PassOwnPtr<ScriptSourceCode> preprocessImpl(InstrumentingAgents* instrumentingAgents, LocalFrame* frame, const ScriptSourceCode& sourceCode)
 136 {
 137     if (InspectorDebuggerAgent* debuggerAgent = instrumentingAgents->inspectorDebuggerAgent())
 138         return debuggerAgent->preprocess(frame, sourceCode);
 139     return PassOwnPtr<ScriptSourceCode>();
 140 }
 141
 142 String preprocessEventListenerImpl(InstrumentingAgents* instrumentingAgents, LocalFrame* frame, const String& source, const String& url, const String& functionName)
 143 {
 144     if (InspectorDebuggerAgent* debuggerAgent = instrumentingAgents->inspectorDebuggerAgent())
 145         return debuggerAgent->preprocessEventListener(frame, source, url, functionName);
 146     return source;
 147 }
 148
 149 void appendAsyncCallStack(ExecutionContext* executionContext, ScriptCallStack* callStack)
 150 {
 151     InstrumentingAgents* instrumentingAgents = instrumentingAgentsFor(executionContext);
 152     if (!instrumentingAgents)
 153         return;
 154     if (InspectorDebuggerAgent* debuggerAgent = instrumentingAgents->inspectorDebuggerAgent())
 155         callStack->setAsyncCallStack(debuggerAgent->currentAsyncStackTraceForConsole());
 156 }
 157
 158 bool canvasAgentEnabled(ExecutionContext* executionContext)
 159 {
 160     InstrumentingAgents* instrumentingAgents = instrumentingAgentsFor(executionContext);
 161     return instrumentingAgents && instrumentingAgents->inspectorCanvasAgent();
 162 }
 163
 164 bool consoleAgentEnabled(ExecutionContext* executionContext)
 165 {
 166     InstrumentingAgents* instrumentingAgents = instrumentingAgentsFor(executionContext);
 167     InspectorConsoleAgent* consoleAgent = instrumentingAgents ? instrumentingAgents->inspectorConsoleAgent() : 0;
 168     return consoleAgent && consoleAgent->enabled();
 169 }
 170
 171 bool timelineAgentEnabled(ExecutionContext* executionContext)
 172 {
 173     InstrumentingAgents* instrumentingAgents = instrumentingAgentsFor(executionContext);
 174     return instrumentingAgents && instrumentingAgents->inspectorTimelineAgent();
 175 }
 176
 177 void registerInstrumentingAgents(InstrumentingAgents* instrumentingAgents)
 178 {
 179     if (!instrumentingAgentsSet)
 180         instrumentingAgentsSet = new HashSet<InstrumentingAgents*>();
 181     instrumentingAgentsSet->add(instrumentingAgents);
 182 }
 183
 184 void unregisterInstrumentingAgents(InstrumentingAgents* instrumentingAgents)
 185 {
 186     if (!instrumentingAgentsSet)
 187         return;
 188     instrumentingAgentsSet->remove(instrumentingAgents);
 189     if (instrumentingAgentsSet->isEmpty()) {
 190         delete instrumentingAgentsSet;
 191         instrumentingAgentsSet = 0;
 192     }
 193 }
 194
 195 InspectorTimelineAgent* retrieveTimelineAgent(const InspectorInstrumentationCookie& cookie)
 196 {
 197     if (!cookie.instrumentingAgents())
 198         return 0;
 199     InspectorTimelineAgent* timelineAgent = cookie.instrumentingAgents()->inspectorTimelineAgent();
 200     if (timelineAgent && cookie.hasMatchingTimelineAgentId(timelineAgent->id()))
 201         return timelineAgent;
 202     return 0;
 203 }
 204
 205 InstrumentingAgents* instrumentingAgentsFor(Page* page)
 206 {
 207     if (!page)
 208         return 0;
 209     return instrumentationForPage(page);
 210 }
 211
 212 InstrumentingAgents* instrumentingAgentsFor(EventTarget* eventTarget)
 213 {
 214     if (!eventTarget)
 215         return 0;
 216     return instrumentingAgentsFor(eventTarget->executionContext());
 217 }
 218
 219 InstrumentingAgents* instrumentingAgentsFor(RenderObject* renderer)
 220 {
 221     return instrumentingAgentsFor(renderer->frame());
 222 }
 223
 224 InstrumentingAgents* instrumentingAgentsFor(WorkerGlobalScope* workerGlobalScope)
 225 {
 226     if (!workerGlobalScope)
 227         return 0;
 228     return instrumentationForWorkerGlobalScope(workerGlobalScope);
 229 }
 230
 231 InstrumentingAgents* instrumentingAgentsForNonDocumentContext(ExecutionContext* context)
 232 {
 233     if (context->isWorkerGlobalScope())
 234         return instrumentationForWorkerGlobalScope(toWorkerGlobalScope(context));
 235     return 0;
 236 }
 237
 238 } // namespace InspectorInstrumentation
 239
 240 namespace InstrumentationEvents {
 241 const char PaintSetup[] = "PaintSetup";
 242 const char RasterTask[] = "RasterTask";
 243 const char Paint[] = "Paint";
 244 const char Layer[] = "Layer";
 245 const char RequestMainThreadFrame[] = "RequestMainThreadFrame";
 246 const char BeginFrame[] = "BeginFrame";
 247 const char ActivateLayerTree[] = "ActivateLayerTree";
 248 const char DrawFrame[] = "DrawFrame";
 249 const char EmbedderCallback[] = "EmbedderCallback";
 250 };
 251
 252 namespace InstrumentationEventArguments {
 253 const char FrameId[] = "frameId";
 254 const char LayerId[] = "layerId";
 255 const char LayerTreeId[] = "layerTreeId";
 256 const char PageId[] = "pageId";
 257 const char CallbackName[] = "callbackName";
 258 };
 259
 260 InstrumentingAgents* instrumentationForPage(Page* page)
 261 {
 262     ASSERT(isMainThread());
 263     return page->inspectorController().m_instrumentingAgents.get();
 264 }
 265
 266 InstrumentingAgents* instrumentationForWorkerGlobalScope(WorkerGlobalScope* workerGlobalScope)
 267 {
 268     if (WorkerInspectorController* controller = workerGlobalScope->workerInspectorController())
 269         return controller->m_instrumentingAgents.get();
 270     return 0;
 271 }
 272
 273 } // namespace blink
 274