First version of PerformanceObserver

Source/core/inspector/AsyncCallTracker.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 20 matching lines @@
 #include "config.h"
 #include "core/inspector/AsyncCallTracker.h"
 
 #include "core/dom/ContextLifecycleObserver.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/events/Event.h"
 #include "core/events/EventTarget.h"
 #include "core/inspector/AsyncOperationMap.h"
 #include "core/inspector/InspectorDebuggerAgent.h"
+#include "core/timing/PerformanceObserver.h"
 #include "core/xmlhttprequest/XMLHttpRequest.h"
 #include "core/xmlhttprequest/XMLHttpRequestUpload.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringHash.h"
 
 namespace {
 
 static const char setTimeoutName[] = "setTimeout";
 static const char setIntervalName[] = "setInterval";
 static const char requestAnimationFrameName[] = "requestAnimationFrame";
 static const char xhrSendName[] = "XMLHttpRequest.send";
 static const char enqueueMutationRecordName[] = "Mutation";
+static const char enqueuePerformanceObservationsName[] = "PerformanceObservation";
 
 }
 
 namespace blink {
 
 class AsyncCallTracker::ExecutionContextData final : public NoBaseWillBeGarbageCollectedFinalized<ExecutionContextData>, public ContextLifecycleObserver {
     WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(AsyncCallTracker::ExecutionContextData);
     WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(AsyncCallTracker::ExecutionContextData);
 public:
     ExecutionContextData(AsyncCallTracker* tracker, ExecutionContext* executionContext)
         : ContextLifecycleObserver(executionContext)
         , m_tracker(tracker)
         , m_timerCallChains(tracker->m_debuggerAgent)
         , m_animationFrameCallChains(tracker->m_debuggerAgent)
         , m_eventCallChains(tracker->m_debuggerAgent)
         , m_xhrCallChains(tracker->m_debuggerAgent)
         , m_mutationObserverCallChains(tracker->m_debuggerAgent)
+        , m_performanceObserverCallChains(tracker->m_debuggerAgent)
         , m_executionContextTaskCallChains(tracker->m_debuggerAgent)
         , m_asyncOperations(tracker->m_debuggerAgent)
     {
     }
 
     void contextDestroyed() override
     {
         ASSERT(executionContext());
         OwnPtrWillBeRawPtr<ExecutionContextData> self = m_tracker->m_executionContextDataMap.take(executionContext());
         ASSERT_UNUSED(self, self == this);
@@ skipping 12 matching lines @@
         visitor->trace(m_tracker);
 #if ENABLE(OILPAN)
         visitor->trace(m_timerCallChains);
         visitor->trace(m_animationFrameCallChains);
         visitor->trace(m_eventCallChains);
         visitor->trace(m_xhrCallChains);
         visitor->trace(m_mutationObserverCallChains);
         visitor->trace(m_executionContextTaskCallChains);
         visitor->trace(m_asyncOperations);
 #endif
+        visitor->trace(m_performanceObserverCallChains);
         ContextLifecycleObserver::trace(visitor);
     }
 
     RawPtrWillBeMember<AsyncCallTracker> m_tracker;
     HashSet<int> m_intervalTimerIds;
     AsyncOperationMap<int> m_timerCallChains;
     AsyncOperationMap<int> m_animationFrameCallChains;
     AsyncOperationMap<RawPtrWillBeMember<Event> > m_eventCallChains;
     AsyncOperationMap<RawPtrWillBeMember<EventTarget> > m_xhrCallChains;
     AsyncOperationMap<RawPtrWillBeMember<MutationObserver> > m_mutationObserverCallChains;
+    AsyncOperationMap<Member<PerformanceObserver>, HeapHashMap<Member<PerformanceObserver>, int>> m_performanceObserverCallChains;
     AsyncOperationMap<ExecutionContextTask*> m_executionContextTaskCallChains;
     AsyncOperationMap<int> m_asyncOperations;
 
 private:
     void disposeCallChains()
     {
         m_timerCallChains.dispose();
         m_animationFrameCallChains.dispose();
         m_eventCallChains.dispose();
         m_xhrCallChains.dispose();
         m_mutationObserverCallChains.dispose();
+        m_performanceObserverCallChains.dispose();
         m_executionContextTaskCallChains.dispose();
         m_asyncOperations.dispose();
     }
 };
 
 static XMLHttpRequest* toXmlHttpRequest(EventTarget* eventTarget)
 {
     const AtomicString& interfaceName = eventTarget->interfaceName();
     if (interfaceName == EventTargetNames::XMLHttpRequest)
         return static_cast<XMLHttpRequest*>(eventTarget);
@@ skipping 188 matching lines @@
     ASSERT(context);
     ASSERT(m_debuggerAgent->trackingAsyncCalls());
     if (ExecutionContextData* data = m_executionContextDataMap.get(context)) {
         willFireAsyncCall(data->m_mutationObserverCallChains.get(observer));
         data->m_mutationObserverCallChains.remove(observer);
     } else {
         willFireAsyncCall(InspectorDebuggerAgent::unknownAsyncOperationId);
     }
 }
 
+void AsyncCallTracker::didEnqueuePerformanceObserverEntries(ExecutionContext* context, PerformanceObserver* observer)

[adamk, 2015/07/24 21:26:30]

Seems sad to have to duplicate all these calls. Wonder if pfeldman has ideas
about reducing copy-pasting here.

+{
+    ASSERT(context);
+    ASSERT(m_debuggerAgent->trackingAsyncCalls());
+    ExecutionContextData* data = createContextDataIfNeeded(context);
+    if (data->m_performanceObserverCallChains.contains(observer))
+        return;
+    int operationId = m_debuggerAgent->traceAsyncOperationStarting(enqueuePerformanceObservationsName);
+    data->m_performanceObserverCallChains.set(observer, operationId);
+}
+
+void AsyncCallTracker::didClearAllPerformanceObservations(ExecutionContext* context, PerformanceObserver* observer)
+{
+    ASSERT(context);
+    ASSERT(m_debuggerAgent->trackingAsyncCalls());
+    if (ExecutionContextData* data = m_executionContextDataMap.get(context))
+        data->m_performanceObserverCallChains.remove(observer);
+}
+
+void AsyncCallTracker::willDeliverPerformanceObservations(ExecutionContext* context, PerformanceObserver* observer)
+{
+    ASSERT(context);
+    ASSERT(m_debuggerAgent->trackingAsyncCalls());
+    if (ExecutionContextData* data = m_executionContextDataMap.get(context)) {
+        willFireAsyncCall(data->m_performanceObserverCallChains.get(observer));
+        data->m_performanceObserverCallChains.remove(observer);
+    } else {
+        willFireAsyncCall(InspectorDebuggerAgent::unknownAsyncOperationId);
+    }
+}
+
 void AsyncCallTracker::didPostExecutionContextTask(ExecutionContext* context, ExecutionContextTask* task)
 {
     ASSERT(context);
     ASSERT(m_debuggerAgent->trackingAsyncCalls());
     if (task->taskNameForInstrumentation().isEmpty())
         return;
     int operationId = m_debuggerAgent->traceAsyncOperationStarting(task->taskNameForInstrumentation());
     ExecutionContextData* data = createContextDataIfNeeded(context);
     data->m_executionContextTaskCallChains.set(task, operationId);
 }
@@ skipping 87 matching lines @@
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_executionContextDataMap);
     visitor->trace(m_debuggerAgent);
     visitor->trace(m_instrumentingAgents);
 #endif
     InspectorDebuggerAgent::AsyncCallTrackingListener::trace(visitor);
 }
 
 } // namespace blink