DevTools: simplify the async instrumentation harness.

third_party/WebKit/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 107 matching lines @@
 public:
     PostMessageTimer(LocalDOMWindow& window, MessageEvent* event, SecurityOrigin* targetOrigin, PassRefPtr<ScriptCallStack> stackTrace, UserGestureToken* userGestureToken)
         : SuspendableTimer(window.document())
         , m_event(event)
         , m_window(&window)
         , m_targetOrigin(targetOrigin)
         , m_stackTrace(stackTrace)
         , m_userGestureToken(userGestureToken)
         , m_disposalAllowed(true)
     {
-        m_asyncOperationId = InspectorInstrumentation::traceAsyncOperationStarting(getExecutionContext(), "postMessage");
+        InspectorInstrumentation::asyncTaskScheduled(window.document(), "postMessage", this);
     }
 
     MessageEvent* event() const { return m_event.get(); }
     SecurityOrigin* targetOrigin() const { return m_targetOrigin.get(); }
     ScriptCallStack* stackTrace() const { return m_stackTrace.get(); }
     UserGestureToken* userGestureToken() const { return m_userGestureToken.get(); }
     void stop() override
     {
         SuspendableTimer::stop();
 
         if (m_disposalAllowed)
             dispose();
     }
 
     // Eager finalization is needed to promptly stop this timer object.
     // (see DOMTimer comment for more.)
     EAGERLY_FINALIZE();
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_event);
         visitor->trace(m_window);
         SuspendableTimer::trace(visitor);
     }
 
     // TODO(alexclarke): Override timerTaskRunner() to pass in a document specific default task runner.
 
 private:
     void fired() override
     {
-        InspectorInstrumentationCookie cookie = InspectorInstrumentation::traceAsyncOperationCompletedCallbackStarting(getExecutionContext(), m_asyncOperationId);
+        InspectorInstrumentation::AsyncTask asyncTask(m_window->document(), this);
         m_disposalAllowed = false;
         m_window->postMessageTimerFired(this);
         dispose();
-        InspectorInstrumentation::traceAsyncCallbackCompleted(cookie);
     }
 
     void dispose()
     {
         // Oilpan optimization: unregister as an observer right away.
         clearContext();
         // Will destroy this object, now or after the next GC depending
         // on whether Oilpan is disabled or not.
         m_window->removePostMessageTimer(this);
     }
 
     Member<MessageEvent> m_event;
     Member<LocalDOMWindow> m_window;
     RefPtr<SecurityOrigin> m_targetOrigin;
     RefPtr<ScriptCallStack> m_stackTrace;
     RefPtr<UserGestureToken> m_userGestureToken;
-    int m_asyncOperationId;
     bool m_disposalAllowed;
 };
 
 static void updateSuddenTerminationStatus(LocalDOMWindow* domWindow, bool addedListener, FrameLoaderClient::SuddenTerminationDisablerType disablerType)
 {
     Platform::current()->suddenTerminationChanged(!addedListener);
     if (domWindow->frame() && domWindow->frame()->loader().client())
         domWindow->frame()->loader().client()->suddenTerminationDisablerChanged(addedListener, disablerType);
 }
 
@@ skipping 1326 matching lines @@
 {
     // If the LocalDOMWindow still has a frame reference, that frame must point
     // back to this LocalDOMWindow: otherwise, it's easy to get into a situation
     // where script execution leaks between different LocalDOMWindows.
     if (m_frameObserver->frame())
         ASSERT_WITH_SECURITY_IMPLICATION(m_frameObserver->frame()->domWindow() == this);
     return m_frameObserver->frame();
 }
 
 } // namespace blink