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

   1 /*
   2  * Copyright (C) 2013 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/AsyncCallStackTracker.h"
  33
  34 #include "bindings/core/v8/V8Binding.h"
  35 #include "bindings/core/v8/V8RecursionScope.h"
  36 #include "core/dom/ExecutionContext.h"
  37 #include "core/dom/ExecutionContextTask.h"
  38 #include "core/dom/Microtask.h"
  39 #include "core/events/Event.h"
  40 #include "core/events/EventTarget.h"
  41 #include "core/xmlhttprequest/XMLHttpRequest.h"
  42 #include "core/xmlhttprequest/XMLHttpRequestUpload.h"
  43 #include "wtf/text/StringBuilder.h"
  44 #include "wtf/text/StringHash.h"
  45 #include <v8.h>
  46
  47 namespace {
  48
  49 static const char setTimeoutName[] = "setTimeout";
  50 static const char setIntervalName[] = "setInterval";
  51 static const char requestAnimationFrameName[] = "requestAnimationFrame";
  52 static const char xhrSendName[] = "XMLHttpRequest.send";
  53 static const char enqueueMutationRecordName[] = "Mutation";
  54
  55 }
  56
  57 namespace blink {
  58
  59 void AsyncCallStackTracker::ExecutionContextData::contextDestroyed()
  60 {
  61     ASSERT(executionContext());
  62     OwnPtrWillBeRawPtr<ExecutionContextData> self = m_tracker->m_executionContextDataMap.take(executionContext());
  63     ASSERT_UNUSED(self, self == this);
  64     ContextLifecycleObserver::contextDestroyed();
  65 }
  66
  67 int AsyncCallStackTracker::ExecutionContextData::circularSequentialID()
  68 {
  69     ++m_circularSequentialID;
  70     if (m_circularSequentialID <= 0)
  71         m_circularSequentialID = 1;
  72     return m_circularSequentialID;
  73 }
  74
  75 void AsyncCallStackTracker::ExecutionContextData::trace(Visitor* visitor)
  76 {
  77     visitor->trace(m_tracker);
  78 #if ENABLE(OILPAN)
  79     visitor->trace(m_timerCallChains);
  80     visitor->trace(m_animationFrameCallChains);
  81     visitor->trace(m_eventCallChains);
  82     visitor->trace(m_xhrCallChains);
  83     visitor->trace(m_mutationObserverCallChains);
  84     visitor->trace(m_executionContextTaskCallChains);
  85     visitor->trace(m_v8AsyncTaskCallChains);
  86     visitor->trace(m_asyncOperationCallChains);
  87 #endif
  88 }
  89
  90 static XMLHttpRequest* toXmlHttpRequest(EventTarget* eventTarget)
  91 {
  92     const AtomicString& interfaceName = eventTarget->interfaceName();
  93     if (interfaceName == EventTargetNames::XMLHttpRequest)
  94         return static_cast<XMLHttpRequest*>(eventTarget);
  95     if (interfaceName == EventTargetNames::XMLHttpRequestUpload)
  96         return static_cast<XMLHttpRequestUpload*>(eventTarget)->xmlHttpRequest();
  97     return 0;
  98 }
  99
 100 void AsyncCallStackTracker::AsyncCallChain::trace(Visitor* visitor)
 101 {
 102     visitor->trace(m_callStacks);
 103 }
 104
 105 AsyncCallStackTracker::AsyncCallStack::AsyncCallStack(const String& description, const ScriptValue& callFrames)
 106     : m_description(description)
 107     , m_callFrames(callFrames)
 108 {
 109 }
 110
 111 AsyncCallStackTracker::AsyncCallStack::~AsyncCallStack()
 112 {
 113 }
 114
 115 AsyncCallStackTracker::AsyncCallStackTracker()
 116     : m_maxAsyncCallStackDepth(0)
 117     , m_nestedAsyncCallCount(0)
 118 {
 119 }
 120
 121 void AsyncCallStackTracker::setAsyncCallStackDepth(int depth)
 122 {
 123     if (depth <= 0) {
 124         m_maxAsyncCallStackDepth = 0;
 125         clear();
 126     } else {
 127         m_maxAsyncCallStackDepth = depth;
 128     }
 129 }
 130
 131 const AsyncCallStackTracker::AsyncCallChain* AsyncCallStackTracker::currentAsyncCallChain() const
 132 {
 133     if (m_currentAsyncCallChain)
 134         ensureMaxAsyncCallChainDepth(m_currentAsyncCallChain.get(), m_maxAsyncCallStackDepth);
 135     return m_currentAsyncCallChain.get();
 136 }
 137
 138 void AsyncCallStackTracker::didInstallTimer(ExecutionContext* context, int timerId, bool singleShot, const ScriptValue& callFrames)
 139 {
 140     ASSERT(context);
 141     ASSERT(isEnabled());
 142     if (!validateCallFrames(callFrames))
 143         return;
 144     ASSERT(timerId > 0);
 145     ExecutionContextData* data = createContextDataIfNeeded(context);
 146     data->m_timerCallChains.set(timerId, createAsyncCallChain(singleShot ? setTimeoutName : setIntervalName, callFrames));
 147     if (!singleShot)
 148         data->m_intervalTimerIds.add(timerId);
 149 }
 150
 151 void AsyncCallStackTracker::didRemoveTimer(ExecutionContext* context, int timerId)
 152 {
 153     ASSERT(context);
 154     ASSERT(isEnabled());
 155     if (timerId <= 0)
 156         return;
 157     ExecutionContextData* data = m_executionContextDataMap.get(context);
 158     if (!data)
 159         return;
 160     data->m_intervalTimerIds.remove(timerId);
 161     data->m_timerCallChains.remove(timerId);
 162 }
 163
 164 void AsyncCallStackTracker::willFireTimer(ExecutionContext* context, int timerId)
 165 {
 166     ASSERT(context);
 167     ASSERT(isEnabled());
 168     ASSERT(timerId > 0);
 169     ASSERT(!m_currentAsyncCallChain);
 170     if (ExecutionContextData* data = m_executionContextDataMap.get(context)) {
 171         if (data->m_intervalTimerIds.contains(timerId))
 172             setCurrentAsyncCallChain(context, data->m_timerCallChains.get(timerId));
 173         else
 174             setCurrentAsyncCallChain(context, data->m_timerCallChains.take(timerId));
 175     } else {
 176         setCurrentAsyncCallChain(context, nullptr);
 177     }
 178 }
 179
 180 void AsyncCallStackTracker::didRequestAnimationFrame(ExecutionContext* context, int callbackId, const ScriptValue& callFrames)
 181 {
 182     ASSERT(context);
 183     ASSERT(isEnabled());
 184     if (!validateCallFrames(callFrames))
 185         return;
 186     ASSERT(callbackId > 0);
 187     ExecutionContextData* data = createContextDataIfNeeded(context);
 188     data->m_animationFrameCallChains.set(callbackId, createAsyncCallChain(requestAnimationFrameName, callFrames));
 189 }
 190
 191 void AsyncCallStackTracker::didCancelAnimationFrame(ExecutionContext* context, int callbackId)
 192 {
 193     ASSERT(context);
 194     ASSERT(isEnabled());
 195     if (callbackId <= 0)
 196         return;
 197     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
 198         data->m_animationFrameCallChains.remove(callbackId);
 199 }
 200
 201 void AsyncCallStackTracker::willFireAnimationFrame(ExecutionContext* context, int callbackId)
 202 {
 203     ASSERT(context);
 204     ASSERT(isEnabled());
 205     ASSERT(callbackId > 0);
 206     ASSERT(!m_currentAsyncCallChain);
 207     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
 208         setCurrentAsyncCallChain(context, data->m_animationFrameCallChains.take(callbackId));
 209     else
 210         setCurrentAsyncCallChain(context, nullptr);
 211 }
 212
 213 void AsyncCallStackTracker::didEnqueueEvent(EventTarget* eventTarget, Event* event, const ScriptValue& callFrames)
 214 {
 215     ASSERT(eventTarget->executionContext());
 216     ASSERT(isEnabled());
 217     if (!validateCallFrames(callFrames))
 218         return;
 219     ExecutionContextData* data = createContextDataIfNeeded(eventTarget->executionContext());
 220     data->m_eventCallChains.set(event, createAsyncCallChain(event->type(), callFrames));
 221 }
 222
 223 void AsyncCallStackTracker::didRemoveEvent(EventTarget* eventTarget, Event* event)
 224 {
 225     ASSERT(eventTarget->executionContext());
 226     ASSERT(isEnabled());
 227     if (ExecutionContextData* data = m_executionContextDataMap.get(eventTarget->executionContext()))
 228         data->m_eventCallChains.remove(event);
 229 }
 230
 231 void AsyncCallStackTracker::willHandleEvent(EventTarget* eventTarget, Event* event, EventListener* listener, bool useCapture)
 232 {
 233     ASSERT(eventTarget->executionContext());
 234     ASSERT(isEnabled());
 235     if (XMLHttpRequest* xhr = toXmlHttpRequest(eventTarget)) {
 236         willHandleXHREvent(xhr, event);
 237     } else {
 238         ExecutionContext* context = eventTarget->executionContext();
 239         if (ExecutionContextData* data = m_executionContextDataMap.get(context))
 240             setCurrentAsyncCallChain(context, data->m_eventCallChains.get(event));
 241         else
 242             setCurrentAsyncCallChain(context, nullptr);
 243     }
 244 }
 245
 246 void AsyncCallStackTracker::willLoadXHR(XMLHttpRequest* xhr, const ScriptValue& callFrames)
 247 {
 248     ASSERT(xhr->executionContext());
 249     ASSERT(isEnabled());
 250     if (!validateCallFrames(callFrames))
 251         return;
 252     ExecutionContextData* data = createContextDataIfNeeded(xhr->executionContext());
 253     data->m_xhrCallChains.set(xhr, createAsyncCallChain(xhrSendName, callFrames));
 254 }
 255
 256 void AsyncCallStackTracker::didLoadXHR(XMLHttpRequest* xhr)
 257 {
 258     ASSERT(xhr->executionContext());
 259     ASSERT(isEnabled());
 260     if (ExecutionContextData* data = m_executionContextDataMap.get(xhr->executionContext()))
 261         data->m_xhrCallChains.remove(xhr);
 262 }
 263
 264 void AsyncCallStackTracker::willHandleXHREvent(XMLHttpRequest* xhr, Event* event)
 265 {
 266     ExecutionContext* context = xhr->executionContext();
 267     ASSERT(context);
 268     ASSERT(isEnabled());
 269     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
 270         setCurrentAsyncCallChain(context, data->m_xhrCallChains.get(xhr));
 271     else
 272         setCurrentAsyncCallChain(context, nullptr);
 273 }
 274
 275 void AsyncCallStackTracker::didEnqueueMutationRecord(ExecutionContext* context, MutationObserver* observer, const ScriptValue& callFrames)
 276 {
 277     ASSERT(context);
 278     ASSERT(isEnabled());
 279     if (!validateCallFrames(callFrames))
 280         return;
 281     ExecutionContextData* data = createContextDataIfNeeded(context);
 282     data->m_mutationObserverCallChains.set(observer, createAsyncCallChain(enqueueMutationRecordName, callFrames));
 283 }
 284
 285 bool AsyncCallStackTracker::hasEnqueuedMutationRecord(ExecutionContext* context, MutationObserver* observer)
 286 {
 287     ASSERT(context);
 288     ASSERT(isEnabled());
 289     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
 290         return data->m_mutationObserverCallChains.contains(observer);
 291     return false;
 292 }
 293
 294 void AsyncCallStackTracker::didClearAllMutationRecords(ExecutionContext* context, MutationObserver* observer)
 295 {
 296     ASSERT(context);
 297     ASSERT(isEnabled());
 298     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
 299         data->m_mutationObserverCallChains.remove(observer);
 300 }
 301
 302 void AsyncCallStackTracker::willDeliverMutationRecords(ExecutionContext* context, MutationObserver* observer)
 303 {
 304     ASSERT(context);
 305     ASSERT(isEnabled());
 306     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
 307         setCurrentAsyncCallChain(context, data->m_mutationObserverCallChains.take(observer));
 308     else
 309         setCurrentAsyncCallChain(context, nullptr);
 310 }
 311
 312 void AsyncCallStackTracker::didPostExecutionContextTask(ExecutionContext* context, ExecutionContextTask* task, const ScriptValue& callFrames)
 313 {
 314     ASSERT(context);
 315     ASSERT(isEnabled());
 316     if (!validateCallFrames(callFrames))
 317         return;
 318     ExecutionContextData* data = createContextDataIfNeeded(context);
 319     data->m_executionContextTaskCallChains.set(task, createAsyncCallChain(task->taskNameForInstrumentation(), callFrames));
 320 }
 321
 322 void AsyncCallStackTracker::didKillAllExecutionContextTasks(ExecutionContext* context)
 323 {
 324     ASSERT(context);
 325     ASSERT(isEnabled());
 326     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
 327         data->m_executionContextTaskCallChains.clear();
 328 }
 329
 330 void AsyncCallStackTracker::willPerformExecutionContextTask(ExecutionContext* context, ExecutionContextTask* task)
 331 {
 332     ASSERT(context);
 333     ASSERT(isEnabled());
 334     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
 335         setCurrentAsyncCallChain(context, data->m_executionContextTaskCallChains.take(task));
 336     else
 337         setCurrentAsyncCallChain(context, nullptr);
 338 }
 339
 340 static String makeV8AsyncTaskUniqueId(const String& eventName, int id)
 341 {
 342     StringBuilder builder;
 343     builder.append(eventName);
 344     builder.appendNumber(id);
 345     return builder.toString();
 346 }
 347
 348 void AsyncCallStackTracker::didEnqueueV8AsyncTask(ExecutionContext* context, const String& eventName, int id, const ScriptValue& callFrames)
 349 {
 350     ASSERT(context);
 351     ASSERT(isEnabled());
 352     if (!validateCallFrames(callFrames))
 353         return;
 354     ExecutionContextData* data = createContextDataIfNeeded(context);
 355     data->m_v8AsyncTaskCallChains.set(makeV8AsyncTaskUniqueId(eventName, id), createAsyncCallChain(eventName, callFrames));
 356 }
 357
 358 void AsyncCallStackTracker::willHandleV8AsyncTask(ExecutionContext* context, const String& eventName, int id)
 359 {
 360     ASSERT(context);
 361     ASSERT(isEnabled());
 362     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
 363         setCurrentAsyncCallChain(context, data->m_v8AsyncTaskCallChains.take(makeV8AsyncTaskUniqueId(eventName, id)));
 364     else
 365         setCurrentAsyncCallChain(context, nullptr);
 366 }
 367
 368 int AsyncCallStackTracker::traceAsyncOperationStarting(ExecutionContext* context, const String& operationName, const ScriptValue& callFrames)
 369 {
 370     ASSERT(context);
 371     ASSERT(isEnabled());
 372     if (!validateCallFrames(callFrames))
 373         return 0;
 374     ExecutionContextData* data = createContextDataIfNeeded(context);
 375     int id = data->circularSequentialID();
 376     while (data->m_asyncOperationCallChains.contains(id))
 377         id = data->circularSequentialID();
 378     data->m_asyncOperationCallChains.set(id, createAsyncCallChain(operationName, callFrames));
 379     return id;
 380 }
 381
 382 void AsyncCallStackTracker::traceAsyncOperationCompleted(ExecutionContext* context, int operationId)
 383 {
 384     ASSERT(context);
 385     ASSERT(isEnabled());
 386     if (operationId <= 0)
 387         return;
 388     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
 389         data->m_asyncOperationCallChains.remove(operationId);
 390 }
 391
 392 void AsyncCallStackTracker::traceAsyncCallbackStarting(ExecutionContext* context, int operationId)
 393 {
 394     ASSERT(context);
 395     ASSERT(isEnabled());
 396     if (ExecutionContextData* data = m_executionContextDataMap.get(context))
 397         setCurrentAsyncCallChain(context, operationId > 0 ? data->m_asyncOperationCallChains.get(operationId) : nullptr);
 398     else
 399         setCurrentAsyncCallChain(context, nullptr);
 400 }
 401
 402 void AsyncCallStackTracker::didFireAsyncCall()
 403 {
 404     clearCurrentAsyncCallChain();
 405 }
 406
 407 PassRefPtrWillBeRawPtr<AsyncCallStackTracker::AsyncCallChain> AsyncCallStackTracker::createAsyncCallChain(const String& description, const ScriptValue& callFrames)
 408 {
 409     if (callFrames.isEmpty()) {
 410         ASSERT(m_currentAsyncCallChain);
 411         return m_currentAsyncCallChain; // Propogate async call stack chain.
 412     }
 413     RefPtrWillBeRawPtr<AsyncCallChain> chain = adoptRefWillBeNoop(m_currentAsyncCallChain ? new AsyncCallStackTracker::AsyncCallChain(*m_currentAsyncCallChain) : new AsyncCallStackTracker::AsyncCallChain());
 414     ensureMaxAsyncCallChainDepth(chain.get(), m_maxAsyncCallStackDepth - 1);
 415     chain->m_callStacks.prepend(adoptRefWillBeNoop(new AsyncCallStackTracker::AsyncCallStack(description, callFrames)));
 416     return chain.release();
 417 }
 418
 419 void AsyncCallStackTracker::setCurrentAsyncCallChain(ExecutionContext* context, PassRefPtrWillBeRawPtr<AsyncCallChain> chain)
 420 {
 421     v8::Isolate* isolate = toIsolate(context);
 422     int recursionLevel = V8RecursionScope::recursionLevel(isolate);
 423     if (chain && (!recursionLevel || (recursionLevel == 1 && Microtask::performingCheckpoint(isolate)))) {
 424         // Current AsyncCallChain corresponds to the bottommost JS call frame.
 425         m_currentAsyncCallChain = chain;
 426         m_nestedAsyncCallCount = 1;
 427     } else {
 428         if (m_currentAsyncCallChain)
 429             ++m_nestedAsyncCallCount;
 430     }
 431 }
 432
 433 void AsyncCallStackTracker::clearCurrentAsyncCallChain()
 434 {
 435     if (!m_nestedAsyncCallCount)
 436         return;
 437     --m_nestedAsyncCallCount;
 438     if (!m_nestedAsyncCallCount)
 439         m_currentAsyncCallChain.clear();
 440 }
 441
 442 void AsyncCallStackTracker::ensureMaxAsyncCallChainDepth(AsyncCallChain* chain, unsigned maxDepth)
 443 {
 444     while (chain->m_callStacks.size() > maxDepth)
 445         chain->m_callStacks.removeLast();
 446 }
 447
 448 bool AsyncCallStackTracker::validateCallFrames(const ScriptValue& callFrames)
 449 {
 450     return !callFrames.isEmpty() || m_currentAsyncCallChain;
 451 }
 452
 453 AsyncCallStackTracker::ExecutionContextData* AsyncCallStackTracker::createContextDataIfNeeded(ExecutionContext* context)
 454 {
 455     ExecutionContextData* data = m_executionContextDataMap.get(context);
 456     if (!data) {
 457         data = m_executionContextDataMap.set(context, adoptPtrWillBeNoop(new AsyncCallStackTracker::ExecutionContextData(this, context)))
 458             .storedValue->value.get();
 459     }
 460     return data;
 461 }
 462
 463 void AsyncCallStackTracker::clear()
 464 {
 465     m_currentAsyncCallChain.clear();
 466     m_nestedAsyncCallCount = 0;
 467     m_executionContextDataMap.clear();
 468 }
 469
 470 void AsyncCallStackTracker::trace(Visitor* visitor)
 471 {
 472     visitor->trace(m_currentAsyncCallChain);
 473 #if ENABLE(OILPAN)
 474     visitor->trace(m_executionContextDataMap);
 475 #endif
 476 }
 477
 478 } // namespace blink