Add ASYNC_STEP support to trace_event and change START to ASYNC_BEGIN.

base/test/trace_event_analyzer.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Use trace_analyzer::Query and trace_analyzer::TraceAnalyzer to search for
 // specific trace events that were generated by the trace_event.h API.
 //
 // Basic procedure:
 // - Get trace events JSON string from base::debug::TraceLog.
 // - Create TraceAnalyzer with JSON string.
@@ skipping 11 matching lines @@
 // a related trace event. The related trace event is typically the matching end
 // of a begin event or the matching begin of an end event.
 //
 // The following examples use this basic setup code to construct TraceAnalyzer
 // with the json trace string retrieved from TraceLog and construct an event
 // vector for retrieving events:
 //
 // TraceAnalyzer analyzer(json_events);
 // TraceEventVector events;
 //
-// During construction, TraceAnalyzer::SetDefaultAssociations is called to
-// associate all matching begin/end pairs similar to how they are shown in
-// about:tracing.
-//
 // EXAMPLE 1: Find events named "my_event".
 //
 // analyzer.FindEvents(Query(EVENT_NAME) == "my_event", &events);
 //
 // EXAMPLE 2: Find begin events named "my_event" with duration > 1 second.
 //
 // Query q = (Query(EVENT_NAME) == Query::String("my_event") &&
 //            Query(EVENT_PHASE) == Query::Phase(TRACE_EVENT_PHASE_BEGIN) &&
 //            Query(EVENT_DURATION) > Query::Double(1000000.0));
 // analyzer.FindEvents(q, &events);
@@ skipping 224 matching lines @@
 
   ////////////////////////////////////////////////////////////////
   // Common queries:
 
   // Find BEGIN events that have a corresponding END event.
   static Query MatchBeginWithEnd() {
     return (Query(EVENT_PHASE) == Query::Phase(TRACE_EVENT_PHASE_BEGIN)) &&
            Query(EVENT_HAS_OTHER);
   }
 
-  // Find START events that have a corresponding FINISH event.
-  static Query MatchStartWithFinish() {
-    return (Query(EVENT_PHASE) == Query::Phase(TRACE_EVENT_PHASE_START)) &&
+  // Find ASYNC_BEGIN events that have a corresponding ASYNC_END event.
+  static Query MatchAsyncBeginWithNext() {
+    return (Query(EVENT_PHASE) ==
+            Query::Phase(TRACE_EVENT_PHASE_ASYNC_BEGIN)) &&
            Query(EVENT_HAS_OTHER);
   }
 
   // Find BEGIN events of given |name| which also have associated END events.
   static Query MatchBeginName(const std::string& name) {
     return (Query(EVENT_NAME) == name) && MatchBeginWithEnd();
   }
 
   // Match given Process ID and Thread ID.
   static Query MatchThread(const TraceEvent::ProcessThreadID& thread) {
@@ skipping 182 matching lines @@
 
   // Use trace events from JSON string generated by tracing API.
   // Returns non-NULL if the JSON is successfully parsed.
   static TraceAnalyzer* Create(const std::string& json_events)
                                WARN_UNUSED_RESULT;
 
   // Associate BEGIN and END events with each other. This allows Query(OTHER_*)
   // to access the associated event and enables Query(EVENT_DURATION).
   // An end event will match the most recent begin event with the same name,
   // category, process ID and thread ID. This matches what is shown in
-  // about:tracing.
+  // about:tracing. After association, the BEGIN event will point to the
+  // matching END event, but the END event will not point to the BEGIN event.
   void AssociateBeginEndEvents();
 
-  // Associate START and FINISH events with each other.
-  // A FINISH event will match the most recent START event with the same name,
-  // category, and ID.
-  void AssociateStartFinishEvents();
+  // Associate ASYNC_BEGIN, ASYNC_STEP and ASYNC_END events with each other.
+  // An ASYNC_END event will match the most recent ASYNC_BEGIN or ASYNC_STEP
+  // event with the same name, category, and ID. This creates a singly linked
+  // list of ASYNC_BEGIN->ASYNC_STEP...->ASYNC_END.
+  void AssociateAsyncBeginEndEvents();
 
   // AssociateEvents can be used to customize event associations by setting the
   // other_event member of TraceEvent. This should be used to associate two
   // INSTANT events.
   //
   // The assumptions are:
   // - |first| events occur before |second| events.
   // - the closest matching |second| event is the correct match.
   //
   // |first|  - Eligible |first| events match this query.
   // |second| - Eligible |second| events match this query.
   // |match|  - This query is run on the |first| event. The OTHER_* EventMember
   //            queries will point to an eligible |second| event. The query
   //            should evaluate to true if the |first|/|second| pair is a match.
   //
-  // When a match is found, the pair will be associated by having their
-  // other_event member point to each other. AssociateEvents does not clear
-  // previous associations, so it is possible to associate multiple pairs of
-  // events by calling AssociateEvents more than once with different queries.
+  // When a match is found, the pair will be associated by having the first
+  // event's other_event member point to the other. AssociateEvents does not
+  // clear previous associations, so it is possible to associate multiple pairs
+  // of events by calling AssociateEvents more than once with different queries.
   //
   // NOTE: AssociateEvents will overwrite existing other_event associations if
   // the queries pass for events that already had a previous association.
   //
   // After calling FindEvents or FindOneEvent, it is not allowed to call
   // AssociateEvents again.
   void AssociateEvents(const Query& first,
                        const Query& second,
                        const Query& match);
 
@@ skipping 70 matching lines @@
 
 // Count all matches.
 static inline size_t CountMatches(const TraceEventVector& events,
                                   const Query& query) {
   return CountMatches(events, query, 0u, events.size());
 }
 
 }  // namespace trace_analyzer
 
 #endif  // BASE_TEST_TRACE_EVENT_ANALYZER_H_