DevTools: Async call stacks for window.postMessage()

Source/core/frame/LocalDOMWindow.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 110 matching lines @@
         : SuspendableTimer(window.document())
         , m_window(window)
         , m_message(message)
         , m_origin(sourceOrigin)
         , m_source(source)
         , m_channels(channels)
         , m_targetOrigin(targetOrigin)
         , m_stackTrace(stackTrace)
         , m_userGestureToken(userGestureToken)
     {
+        m_asyncOperationId = InspectorInstrumentation::traceAsyncOperationStarting(executionContext(), "postMessage");

[yurys, 2014/07/21 12:45:32]

If we are OK with storing async id in the instrumented instance, are you
planning to switch other async stacks instrumentation to the new API?

[aandrey, 2014/07/22 11:08:43]

Yes, something like ExecutionContextTask/FileSystemAPI should be easily
switchable, but for others like setTimeout/requestAnimFrame, we  would still
need to have a place to match timeoutId to asyncOperationId, so it makes no
sense to switch.

     }
 
     PassRefPtrWillBeRawPtr<MessageEvent> event()
     {
         return MessageEvent::create(m_channels.release(), m_message, m_origin, String(), m_source.get());
 
     }
     SecurityOrigin* targetOrigin() const { return m_targetOrigin.get(); }
     ScriptCallStack* stackTrace() const { return m_stackTrace.get(); }
     UserGestureToken* userGestureToken() const { return m_userGestureToken.get(); }
 
 private:
     virtual void fired() OVERRIDE
     {
+        InspectorInstrumentationCookie cookie = InspectorInstrumentation::traceAsyncOperationCompletedCallbackStarting(executionContext(), m_asyncOperationId);

[yurys, 2014/07/21 12:45:32]

Why do you need to merge two hooks into one?

[aandrey, 2014/07/22 11:08:43]

To have only one instrumentation call here. Actually this "combined" method is
the most useful, but should we want to expose it in public API we should
separate it to be flexible.

[yurys, 2014/07/22 13:09:43]

Why is it marked as completed only here? Shouldn't it be done where the
PostMessageTimer is created and scheduled?

[aandrey, 2014/07/22 13:32:14]

No, it's on the right place.
The async operation "completed" means that there will be no more callbacks, and
we can delete the async stack trace associated with the operation. Until this
place we do need that async stack and cannot say the operation is "completed"
before this place.

The traceAsyncOperationCompletedCallbackStarting actually does:
1) traceAsyncCallbackStarting    => we save the async stack as "current"
2) traceAsyncOperationCompleted  => we delete the async stack

         m_window->postMessageTimerFired(adoptPtr(this));
         // This object is deleted now.
+        InspectorInstrumentation::traceAsyncCallbackCompleted(cookie);
     }
 
     RefPtrWillBePersistent<LocalDOMWindow> m_window;
     RefPtr<SerializedScriptValue> m_message;
     String m_origin;
     RefPtrWillBePersistent<LocalDOMWindow> m_source;
     OwnPtr<MessagePortChannelArray> m_channels;
     RefPtr<SecurityOrigin> m_targetOrigin;
     RefPtrWillBePersistent<ScriptCallStack> m_stackTrace;
     RefPtr<UserGestureToken> m_userGestureToken;
+    int m_asyncOperationId;
 };
 
 static void disableSuddenTermination()
 {
     blink::Platform::current()->suddenTerminationChanged(false);
 }
 
 static void enableSuddenTermination()
 {
     blink::Platform::current()->suddenTerminationChanged(true);
@@ skipping 1775 matching lines @@
     visitor->trace(m_localStorage);
     visitor->trace(m_applicationCache);
     visitor->trace(m_performance);
     visitor->trace(m_css);
     visitor->trace(m_eventQueue);
     WillBeHeapSupplementable<LocalDOMWindow>::trace(visitor);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace blink