1 /* 2 * Copyright (C) 2010 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 #ifndef InspectorInstrumentation_h 32 #define InspectorInstrumentation_h 33 34 #include "bindings/core/v8/ScriptString.h" 35 #include "core/css/CSSSelector.h" 36 #include "core/css/CSSStyleDeclaration.h" 37 #include "core/css/CSSStyleSheet.h" 38 #include "core/dom/CharacterData.h" 39 #include "core/dom/Element.h" 40 #include "core/dom/ExecutionContext.h" 41 #include "core/events/NodeEventContext.h" 42 #include "core/frame/LocalFrame.h" 43 #include "core/inspector/ConsoleAPITypes.h" 44 #include "core/rendering/HitTestResult.h" 45 #include "core/rendering/RenderImage.h" 46 #include "core/storage/StorageArea.h" 47 #include "platform/network/FormData.h" 48 #include "platform/network/WebSocketHandshakeRequest.h" 49 #include "platform/network/WebSocketHandshakeResponse.h" 50 #include "wtf/RefPtr.h" 51 52 namespace blink { 53 54 struct CSSParserString; 55 class Document; 56 class Element; 57 class EventTarget; 58 class ExecutionContext; 59 class GraphicsContext; 60 class GraphicsLayer; 61 class InspectorTimelineAgent; 62 class InstrumentingAgents; 63 class RenderLayer; 64 class ThreadableLoaderClient; 65 class WorkerGlobalScope; 66 class WorkerInspectorProxy; 67 68 #define FAST_RETURN_IF_NO_FRONTENDS(value) if (!hasFrontends()) return value; 69 70 class InspectorInstrumentationCookie { 71 public: 72 InspectorInstrumentationCookie(); 73 InspectorInstrumentationCookie(InstrumentingAgents*, int); 74 InspectorInstrumentationCookie(const InspectorInstrumentationCookie&); 75 InspectorInstrumentationCookie& operator=(const InspectorInstrumentationCookie&); 76 ~InspectorInstrumentationCookie(); 77 78 InstrumentingAgents* instrumentingAgents() const { return m_instrumentingAgents.get(); } 79 bool isValid() const { return !!m_instrumentingAgents; } 80 bool hasMatchingTimelineAgentId(int id) const { return m_timelineAgentId == id; } 81 82 private: 83 RefPtrWillBePersistent<InstrumentingAgents> m_instrumentingAgents; 84 int m_timelineAgentId; 85 }; 86 87 namespace InspectorInstrumentation { 88 89 class FrontendCounter { 90 private: 91 friend void frontendCreated(); 92 friend void frontendDeleted(); 93 friend bool hasFrontends(); 94 static int s_frontendCounter; 95 }; 96 97 inline void frontendCreated() { atomicIncrement(&FrontendCounter::s_frontendCounter); } 98 inline void frontendDeleted() { atomicDecrement(&FrontendCounter::s_frontendCounter); } 99 inline bool hasFrontends() { return FrontendCounter::s_frontendCounter; } 100 101 void registerInstrumentingAgents(InstrumentingAgents*); 102 void unregisterInstrumentingAgents(InstrumentingAgents*); 103 104 InspectorTimelineAgent* retrieveTimelineAgent(const InspectorInstrumentationCookie&); 105 106 // Called from generated instrumentation code. 107 InstrumentingAgents* instrumentingAgentsFor(Page*); 108 InstrumentingAgents* instrumentingAgentsFor(LocalFrame*); 109 InstrumentingAgents* instrumentingAgentsFor(EventTarget*); 110 InstrumentingAgents* instrumentingAgentsFor(ExecutionContext*); 111 InstrumentingAgents* instrumentingAgentsFor(Document&); 112 InstrumentingAgents* instrumentingAgentsFor(Document*); 113 InstrumentingAgents* instrumentingAgentsFor(RenderObject*); 114 InstrumentingAgents* instrumentingAgentsFor(Node*); 115 InstrumentingAgents* instrumentingAgentsFor(WorkerGlobalScope*); 116 117 // Helper for the one above. 118 InstrumentingAgents* instrumentingAgentsForNonDocumentContext(ExecutionContext*); 119 120 } // namespace InspectorInstrumentation 121 122 namespace InstrumentationEvents { 123 extern const char PaintSetup[]; 124 extern const char RasterTask[]; 125 extern const char Paint[]; 126 extern const char Layer[]; 127 extern const char RequestMainThreadFrame[]; 128 extern const char BeginFrame[]; 129 extern const char DrawFrame[]; 130 extern const char ActivateLayerTree[]; 131 extern const char EmbedderCallback[]; 132 }; 133 134 namespace InstrumentationEventArguments { 135 extern const char FrameId[]; 136 extern const char LayerId[]; 137 extern const char LayerTreeId[]; 138 extern const char PageId[]; 139 extern const char CallbackName[]; 140 }; 141 142 namespace InspectorInstrumentation { 143 144 inline InstrumentingAgents* instrumentingAgentsFor(ExecutionContext* context) 145 { 146 if (!context) 147 return 0; 148 return context->isDocument() ? instrumentingAgentsFor(*toDocument(context)) : instrumentingAgentsForNonDocumentContext(context); 149 } 150 151 inline InstrumentingAgents* instrumentingAgentsFor(LocalFrame* frame) 152 { 153 return frame ? instrumentingAgentsFor(frame->page()) : 0; 154 } 155 156 inline InstrumentingAgents* instrumentingAgentsFor(Document& document) 157 { 158 Page* page = document.page(); 159 if (!page && document.templateDocumentHost()) 160 page = document.templateDocumentHost()->page(); 161 return instrumentingAgentsFor(page); 162 } 163 164 inline InstrumentingAgents* instrumentingAgentsFor(Document* document) 165 { 166 return document ? instrumentingAgentsFor(*document) : 0; 167 } 168 169 inline InstrumentingAgents* instrumentingAgentsFor(CSSStyleSheet* styleSheet) 170 { 171 return styleSheet ? instrumentingAgentsFor(styleSheet->ownerDocument()) : 0; 172 } 173 174 inline InstrumentingAgents* instrumentingAgentsFor(Node* node) 175 { 176 return node ? instrumentingAgentsFor(node->document()) : 0; 177 } 178 179 inline InstrumentingAgents* instrumentingAgentsFor(CSSStyleDeclaration* declaration) 180 { 181 return declaration ? instrumentingAgentsFor(declaration->parentStyleSheet()) : 0; 182 } 183 184 } // namespace InspectorInstrumentation 185 186 InstrumentingAgents* instrumentationForPage(Page*); 187 188 InstrumentingAgents* instrumentationForWorkerGlobalScope(WorkerGlobalScope*); 189 190 } // namespace blink 191 192 #include "core/InspectorInstrumentationInl.h" 193 194 #include "core/inspector/InspectorInstrumentationCustomInl.h" 195 196 #include "core/InspectorOverridesInl.h" 197 198 #endif // !defined(InspectorInstrumentation_h) 199