src/third_party/WebKit/Source/core/inspector/InspectorCanvasAgent.cpp

   1 /*
   2  * Copyright (C) 2012 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/InspectorCanvasAgent.h"
  33
  34 #include "bindings/core/v8/ScriptProfiler.h"
  35 #include "bindings/core/v8/ScriptValue.h"
  36 #include "core/html/HTMLCanvasElement.h"
  37 #include "core/inspector/BindingVisitors.h"
  38 #include "core/inspector/InjectedScript.h"
  39 #include "core/inspector/InjectedScriptCanvasModule.h"
  40 #include "core/inspector/InjectedScriptManager.h"
  41 #include "core/inspector/InspectorPageAgent.h"
  42 #include "core/inspector/InspectorState.h"
  43 #include "core/inspector/InstrumentingAgents.h"
  44 #include "core/loader/DocumentLoader.h"
  45 #include "core/frame/LocalDOMWindow.h"
  46 #include "core/frame/LocalFrame.h"
  47
  48 using blink::TypeBuilder::Array;
  49 using blink::TypeBuilder::Canvas::ResourceId;
  50 using blink::TypeBuilder::Canvas::ResourceState;
  51 using blink::TypeBuilder::Canvas::TraceLog;
  52 using blink::TypeBuilder::Canvas::TraceLogId;
  53 using blink::TypeBuilder::Page::FrameId;
  54 using blink::TypeBuilder::Runtime::RemoteObject;
  55
  56 namespace blink {
  57
  58 namespace CanvasAgentState {
  59 static const char canvasAgentEnabled[] = "canvasAgentEnabled";
  60 };
  61
  62 InspectorCanvasAgent::InspectorCanvasAgent(InspectorPageAgent* pageAgent, InjectedScriptManager* injectedScriptManager)
  63     : InspectorBaseAgent<InspectorCanvasAgent>("Canvas")
  64     , m_pageAgent(pageAgent)
  65     , m_injectedScriptManager(injectedScriptManager)
  66     , m_frontend(0)
  67     , m_enabled(false)
  68 {
  69 }
  70
  71 InspectorCanvasAgent::~InspectorCanvasAgent()
  72 {
  73 }
  74
  75 void InspectorCanvasAgent::trace(Visitor* visitor)
  76 {
  77     visitor->trace(m_pageAgent);
  78     visitor->trace(m_injectedScriptManager);
  79     InspectorBaseAgent::trace(visitor);
  80 }
  81
  82 void InspectorCanvasAgent::setFrontend(InspectorFrontend* frontend)
  83 {
  84     ASSERT(frontend);
  85     m_frontend = frontend->canvas();
  86 }
  87
  88 void InspectorCanvasAgent::clearFrontend()
  89 {
  90     m_frontend = 0;
  91     disable(0);
  92 }
  93
  94 void InspectorCanvasAgent::restore()
  95 {
  96     if (m_state->getBoolean(CanvasAgentState::canvasAgentEnabled)) {
  97         ErrorString error;
  98         enable(&error);
  99     }
 100 }
 101
 102 void InspectorCanvasAgent::enable(ErrorString*)
 103 {
 104     if (m_enabled)
 105         return;
 106     m_enabled = true;
 107     m_state->setBoolean(CanvasAgentState::canvasAgentEnabled, m_enabled);
 108     m_instrumentingAgents->setInspectorCanvasAgent(this);
 109     findFramesWithUninstrumentedCanvases();
 110 }
 111
 112 void InspectorCanvasAgent::disable(ErrorString*)
 113 {
 114     m_enabled = false;
 115     m_state->setBoolean(CanvasAgentState::canvasAgentEnabled, m_enabled);
 116     m_instrumentingAgents->setInspectorCanvasAgent(0);
 117     m_framesWithUninstrumentedCanvases.clear();
 118     if (m_frontend)
 119         m_frontend->traceLogsRemoved(0, 0);
 120 }
 121
 122 void InspectorCanvasAgent::dropTraceLog(ErrorString* errorString, const TraceLogId& traceLogId)
 123 {
 124     InjectedScriptCanvasModule module = injectedScriptCanvasModule(errorString, traceLogId);
 125     if (!module.isEmpty())
 126         module.dropTraceLog(errorString, traceLogId);
 127 }
 128
 129 void InspectorCanvasAgent::hasUninstrumentedCanvases(ErrorString* errorString, bool* result)
 130 {
 131     if (!checkIsEnabled(errorString))
 132         return;
 133     for (FramesWithUninstrumentedCanvases::const_iterator it = m_framesWithUninstrumentedCanvases.begin(); it != m_framesWithUninstrumentedCanvases.end(); ++it) {
 134         if (it->value) {
 135             *result = true;
 136             return;
 137         }
 138     }
 139     *result = false;
 140 }
 141
 142 void InspectorCanvasAgent::captureFrame(ErrorString* errorString, const FrameId* frameId, TraceLogId* traceLogId)
 143 {
 144     LocalFrame* frame = frameId ? m_pageAgent->assertFrame(errorString, *frameId) : m_pageAgent->mainFrame();
 145     if (!frame)
 146         return;
 147     InjectedScriptCanvasModule module = injectedScriptCanvasModule(errorString, ScriptState::forMainWorld(frame));
 148     if (!module.isEmpty())
 149         module.captureFrame(errorString, traceLogId);
 150 }
 151
 152 void InspectorCanvasAgent::startCapturing(ErrorString* errorString, const FrameId* frameId, TraceLogId* traceLogId)
 153 {
 154     LocalFrame* frame = frameId ? m_pageAgent->assertFrame(errorString, *frameId) : m_pageAgent->mainFrame();
 155     if (!frame)
 156         return;
 157     InjectedScriptCanvasModule module = injectedScriptCanvasModule(errorString, ScriptState::forMainWorld(frame));
 158     if (!module.isEmpty())
 159         module.startCapturing(errorString, traceLogId);
 160 }
 161
 162 void InspectorCanvasAgent::stopCapturing(ErrorString* errorString, const TraceLogId& traceLogId)
 163 {
 164     InjectedScriptCanvasModule module = injectedScriptCanvasModule(errorString, traceLogId);
 165     if (!module.isEmpty())
 166         module.stopCapturing(errorString, traceLogId);
 167 }
 168
 169 void InspectorCanvasAgent::getTraceLog(ErrorString* errorString, const TraceLogId& traceLogId, const int* startOffset, const int* maxLength, RefPtr<TraceLog>& traceLog)
 170 {
 171     InjectedScriptCanvasModule module = injectedScriptCanvasModule(errorString, traceLogId);
 172     if (!module.isEmpty())
 173         module.traceLog(errorString, traceLogId, startOffset, maxLength, &traceLog);
 174 }
 175
 176 void InspectorCanvasAgent::replayTraceLog(ErrorString* errorString, const TraceLogId& traceLogId, int stepNo, RefPtr<ResourceState>& result, double* replayTime)
 177 {
 178     InjectedScriptCanvasModule module = injectedScriptCanvasModule(errorString, traceLogId);
 179     if (!module.isEmpty())
 180         module.replayTraceLog(errorString, traceLogId, stepNo, &result, replayTime);
 181 }
 182
 183 void InspectorCanvasAgent::getResourceState(ErrorString* errorString, const TraceLogId& traceLogId, const ResourceId& resourceId, RefPtr<ResourceState>& result)
 184 {
 185     InjectedScriptCanvasModule module = injectedScriptCanvasModule(errorString, traceLogId);
 186     if (!module.isEmpty())
 187         module.resourceState(errorString, traceLogId, resourceId, &result);
 188 }
 189
 190 void InspectorCanvasAgent::evaluateTraceLogCallArgument(ErrorString* errorString, const TraceLogId& traceLogId, int callIndex, int argumentIndex, const String* objectGroup, RefPtr<RemoteObject>& result, RefPtr<ResourceState>& resourceState)
 191 {
 192     InjectedScriptCanvasModule module = injectedScriptCanvasModule(errorString, traceLogId);
 193     if (!module.isEmpty())
 194         module.evaluateTraceLogCallArgument(errorString, traceLogId, callIndex, argumentIndex, objectGroup ? *objectGroup : String(), &result, &resourceState);
 195 }
 196
 197 ScriptValue InspectorCanvasAgent::wrapCanvas2DRenderingContextForInstrumentation(const ScriptValue& context)
 198 {
 199     ErrorString error;
 200     InjectedScriptCanvasModule module = injectedScriptCanvasModule(&error, context);
 201     if (module.isEmpty())
 202         return ScriptValue();
 203     return notifyRenderingContextWasWrapped(module.wrapCanvas2DContext(context));
 204 }
 205
 206 ScriptValue InspectorCanvasAgent::wrapWebGLRenderingContextForInstrumentation(const ScriptValue& glContext)
 207 {
 208     ErrorString error;
 209     InjectedScriptCanvasModule module = injectedScriptCanvasModule(&error, glContext);
 210     if (module.isEmpty())
 211         return ScriptValue();
 212     return notifyRenderingContextWasWrapped(module.wrapWebGLContext(glContext));
 213 }
 214
 215 ScriptValue InspectorCanvasAgent::notifyRenderingContextWasWrapped(const ScriptValue& wrappedContext)
 216 {
 217     ASSERT(m_frontend);
 218     ScriptState* scriptState = wrappedContext.scriptState();
 219     LocalDOMWindow* domWindow = 0;
 220     if (scriptState)
 221         domWindow = scriptState->domWindow();
 222     LocalFrame* frame = domWindow ? domWindow->frame() : 0;
 223     if (frame && !m_framesWithUninstrumentedCanvases.contains(frame))
 224         m_framesWithUninstrumentedCanvases.set(frame, false);
 225     String frameId = m_pageAgent->frameId(frame);
 226     if (!frameId.isEmpty())
 227         m_frontend->contextCreated(frameId);
 228     return wrappedContext;
 229 }
 230
 231 InjectedScriptCanvasModule InspectorCanvasAgent::injectedScriptCanvasModule(ErrorString* errorString, ScriptState* scriptState)
 232 {
 233     if (!checkIsEnabled(errorString))
 234         return InjectedScriptCanvasModule();
 235     InjectedScriptCanvasModule module = InjectedScriptCanvasModule::moduleForState(m_injectedScriptManager, scriptState);
 236     if (module.isEmpty()) {
 237         ASSERT_NOT_REACHED();
 238         *errorString = "Internal error: no Canvas module";
 239     }
 240     return module;
 241 }
 242
 243 InjectedScriptCanvasModule InspectorCanvasAgent::injectedScriptCanvasModule(ErrorString* errorString, const ScriptValue& scriptValue)
 244 {
 245     if (!checkIsEnabled(errorString))
 246         return InjectedScriptCanvasModule();
 247     if (scriptValue.isEmpty()) {
 248         ASSERT_NOT_REACHED();
 249         *errorString = "Internal error: original ScriptValue has no value";
 250         return InjectedScriptCanvasModule();
 251     }
 252     return injectedScriptCanvasModule(errorString, scriptValue.scriptState());
 253 }
 254
 255 InjectedScriptCanvasModule InspectorCanvasAgent::injectedScriptCanvasModule(ErrorString* errorString, const String& objectId)
 256 {
 257     if (!checkIsEnabled(errorString))
 258         return InjectedScriptCanvasModule();
 259     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptForObjectId(objectId);
 260     if (injectedScript.isEmpty()) {
 261         *errorString = "Inspected frame has gone";
 262         return InjectedScriptCanvasModule();
 263     }
 264     return injectedScriptCanvasModule(errorString, injectedScript.scriptState());
 265 }
 266
 267 void InspectorCanvasAgent::findFramesWithUninstrumentedCanvases()
 268 {
 269     class NodeVisitor FINAL : public WrappedNodeVisitor {
 270     public:
 271         NodeVisitor(Page* page, FramesWithUninstrumentedCanvases& result)
 272             : m_page(page)
 273             , m_framesWithUninstrumentedCanvases(result)
 274         {
 275         }
 276
 277         virtual void visitNode(Node* node) OVERRIDE
 278         {
 279             ASSERT(node);
 280             if (!isHTMLCanvasElement(*node) || !node->document().frame())
 281                 return;
 282
 283             LocalFrame* frame = node->document().frame();
 284             if (frame->page() != m_page)
 285                 return;
 286
 287             if (toHTMLCanvasElement(node)->renderingContext())
 288                 m_framesWithUninstrumentedCanvases.set(frame, true);
 289         }
 290
 291     private:
 292         Page* m_page;
 293         FramesWithUninstrumentedCanvases& m_framesWithUninstrumentedCanvases;
 294     } nodeVisitor(m_pageAgent->page(), m_framesWithUninstrumentedCanvases);
 295
 296     m_framesWithUninstrumentedCanvases.clear();
 297     ScriptProfiler::visitNodeWrappers(&nodeVisitor);
 298
 299     if (m_frontend) {
 300         for (FramesWithUninstrumentedCanvases::const_iterator it = m_framesWithUninstrumentedCanvases.begin(); it != m_framesWithUninstrumentedCanvases.end(); ++it) {
 301             String frameId = m_pageAgent->frameId(it->key);
 302             if (!frameId.isEmpty())
 303                 m_frontend->contextCreated(frameId);
 304         }
 305     }
 306 }
 307
 308 bool InspectorCanvasAgent::checkIsEnabled(ErrorString* errorString) const
 309 {
 310     if (m_enabled)
 311         return true;
 312     *errorString = "Canvas agent is not enabled";
 313     return false;
 314 }
 315
 316 void InspectorCanvasAgent::didCommitLoad(LocalFrame*, DocumentLoader* loader)
 317 {
 318     if (!m_enabled)
 319         return;
 320     Frame* frame = loader->frame();
 321     if (frame == m_pageAgent->mainFrame()) {
 322         for (FramesWithUninstrumentedCanvases::iterator it = m_framesWithUninstrumentedCanvases.begin(); it != m_framesWithUninstrumentedCanvases.end(); ++it)
 323             it->value = false;
 324         m_frontend->traceLogsRemoved(0, 0);
 325     } else {
 326         while (frame) {
 327             if (frame->isLocalFrame()) {
 328                 LocalFrame* localFrame = toLocalFrame(frame);
 329                 if (m_framesWithUninstrumentedCanvases.contains(localFrame))
 330                     m_framesWithUninstrumentedCanvases.set(localFrame, false);
 331                 if (m_pageAgent->hasIdForFrame(localFrame)) {
 332                     String frameId = m_pageAgent->frameId(localFrame);
 333                     m_frontend->traceLogsRemoved(&frameId, 0);
 334                 }
 335             }
 336             frame = frame->tree().traverseNext();
 337         }
 338     }
 339 }
 340
 341 void InspectorCanvasAgent::frameDetachedFromParent(LocalFrame* frame)
 342 {
 343     if (m_enabled)
 344         m_framesWithUninstrumentedCanvases.remove(frame);
 345 }
 346
 347 void InspectorCanvasAgent::didBeginFrame()
 348 {
 349     if (!m_enabled)
 350         return;
 351     ErrorString error;
 352     for (FramesWithUninstrumentedCanvases::const_iterator it = m_framesWithUninstrumentedCanvases.begin(); it != m_framesWithUninstrumentedCanvases.end(); ++it) {
 353         InjectedScriptCanvasModule module = injectedScriptCanvasModule(&error, ScriptState::forMainWorld(it->key));
 354         if (!module.isEmpty())
 355             module.markFrameEnd();
 356     }
 357 }
 358
 359 } // namespace blink
 360