Add ASYNC_STEP support to trace_event and change START to ASYNC_BEGIN.

base/test/trace_event_analyzer.cc

 // 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.
 
 #include "base/test/trace_event_analyzer.h"
 
 #include <algorithm>
 #include <math.h>
+#include <set>
 
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 
 namespace trace_analyzer {
 
 // TraceEvent
 
 TraceEvent::TraceEvent()
@@ skipping 18 matching lines @@
   base::DictionaryValue* args = NULL;
 
   if (!dictionary->GetString("ph", &phase_str)) {
     LOG(ERROR) << "ph is missing from TraceEvent JSON";
     return false;
   }
 
   phase = *phase_str.data();
 
   bool require_origin = (phase != TRACE_EVENT_PHASE_METADATA);
-  bool require_id = (phase == TRACE_EVENT_PHASE_START ||
-                     phase == TRACE_EVENT_PHASE_FINISH);
+  bool require_id = (phase == TRACE_EVENT_PHASE_ASYNC_BEGIN ||
+                     phase == TRACE_EVENT_PHASE_ASYNC_STEP ||
+                     phase == TRACE_EVENT_PHASE_ASYNC_END);
 
   if (require_origin && !dictionary->GetInteger("pid", &thread.process_id)) {
     LOG(ERROR) << "pid is missing from TraceEvent JSON";
     return false;
   }
   if (require_origin && !dictionary->GetInteger("tid", &thread.thread_id)) {
     LOG(ERROR) << "tid is missing from TraceEvent JSON";
     return false;
   }
   if (require_origin && !dictionary->GetDouble("ts", &timestamp)) {
     LOG(ERROR) << "ts is missing from TraceEvent JSON";
     return false;
   }
   if (!dictionary->GetString("cat", &category)) {
     LOG(ERROR) << "cat is missing from TraceEvent JSON";
     return false;
   }
   if (!dictionary->GetString("name", &name)) {
     LOG(ERROR) << "name is missing from TraceEvent JSON";
     return false;
   }
   if (!dictionary->GetDictionary("args", &args)) {
     LOG(ERROR) << "args is missing from TraceEvent JSON";
     return false;
   }
   if (require_id && !dictionary->GetString("id", &id)) {
-    LOG(ERROR) << "id is missing from START/FINISH TraceEvent JSON";
+    LOG(ERROR) << "id is missing from ASYNC_BEGIN/ASYNC_END TraceEvent JSON";
     return false;
   }
 
   // For each argument, copy the type and create a trace_analyzer::TraceValue.
   base::DictionaryValue::key_iterator keyi = args->begin_keys();
   for (; keyi != args->end_keys(); ++keyi) {
     std::string str;
     bool boolean = false;
     int int_num = 0;
     double double_num = 0.0;
@@ skipping 609 matching lines @@
   Query begin(Query::EventPhase() == Query::Phase(TRACE_EVENT_PHASE_BEGIN));
   Query end(Query::EventPhase() == Query::Phase(TRACE_EVENT_PHASE_END));
   Query match(Query::EventName() == Query::OtherName() &&
               Query::EventCategory() == Query::OtherCategory() &&
               Query::EventTid() == Query::OtherTid() &&
               Query::EventPid() == Query::OtherPid());
 
   AssociateEvents(begin, end, match);
 }
 
-void TraceAnalyzer::AssociateStartFinishEvents() {
+void TraceAnalyzer::AssociateAsyncBeginEndEvents() {
   using trace_analyzer::Query;
 
-  Query begin(Query::EventPhase() == Query::Phase(TRACE_EVENT_PHASE_START));
-  Query end(Query::EventPhase() == Query::Phase(TRACE_EVENT_PHASE_FINISH));
+  Query begin(
+      Query::EventPhase() == Query::Phase(TRACE_EVENT_PHASE_ASYNC_BEGIN) ||
+      Query::EventPhase() == Query::Phase(TRACE_EVENT_PHASE_ASYNC_STEP));
+  Query end(Query::EventPhase() == Query::Phase(TRACE_EVENT_PHASE_ASYNC_END) ||
+            Query::EventPhase() == Query::Phase(TRACE_EVENT_PHASE_ASYNC_STEP));
   Query match(Query::EventName() == Query::OtherName() &&
               Query::EventCategory() == Query::OtherCategory() &&
               Query::EventId() == Query::OtherId());
 
   AssociateEvents(begin, end, match);
 }
 
 void TraceAnalyzer::AssociateEvents(const Query& first,
                                     const Query& second,
                                     const Query& match) {
   DCHECK(allow_assocation_changes_) << "AssociateEvents not allowed after "
                                       "FindEvents";
 
   // Search for matching begin/end event pairs. When a matching end is found,
   // it is associated with the begin event.
   std::vector<TraceEvent*> begin_stack;
   for (size_t event_index = 0; event_index < raw_events_.size();
        ++event_index) {
 
     TraceEvent& this_event = raw_events_[event_index];
 
-    if (first.Evaluate(this_event)) {
-      begin_stack.push_back(&this_event);
-    } else if (second.Evaluate(this_event)) {
+    if (second.Evaluate(this_event)) {
       // Search stack for matching begin, starting from end.
       for (int stack_index = static_cast<int>(begin_stack.size()) - 1;
            stack_index >= 0; --stack_index) {
         TraceEvent& begin_event = *begin_stack[stack_index];
 
         // Temporarily set other to test against the match query.
         const TraceEvent* other_backup = begin_event.other_event;
         begin_event.other_event = &this_event;
         if (match.Evaluate(begin_event)) {
           // Found a matching begin/end pair.
-          // Set event association:
-          this_event.other_event = &begin_event;
           // Erase the matching begin event index from the stack.
           begin_stack.erase(begin_stack.begin() + stack_index);
           break;
         }
 
         // Not a match, restore original other and continue.
         begin_event.other_event = other_backup;
       }
     }
+    // Even if this_event is a |second| event that has matched an earlier
+    // |first| event, it can still also be a |first| event and be associated
+    // with a later |second| event.
+    if (first.Evaluate(this_event)) {
+      begin_stack.push_back(&this_event);
+    }
   }
 }
 
 void TraceAnalyzer::MergeAssociatedEventArgs() {
   for (size_t i = 0; i < raw_events_.size(); ++i) {
-    if (raw_events_[i].other_event) {
+    // Merge all associated events with the first event.
+    const TraceEvent* other = raw_events_[i].other_event;
+    // Avoid looping by keeping set of encountered TraceEvents.
+    std::set<const TraceEvent*> encounters;
+    encounters.insert(&raw_events_[i]);
+    while (other && encounters.find(other) == encounters.end()) {
+      encounters.insert(other);
       raw_events_[i].arg_numbers.insert(
-          raw_events_[i].other_event->arg_numbers.begin(),
-          raw_events_[i].other_event->arg_numbers.end());
+          other->arg_numbers.begin(),
+          other->arg_numbers.end());
       raw_events_[i].arg_strings.insert(
-          raw_events_[i].other_event->arg_strings.begin(),
-          raw_events_[i].other_event->arg_strings.end());
+          other->arg_strings.begin(),
+          other->arg_strings.end());
+      other = other->other_event;
     }
   }
 }
 
 size_t TraceAnalyzer::FindEvents(const Query& query, TraceEventVector* output) {
   allow_assocation_changes_ = false;
   output->clear();
   return FindMatchingEvents(raw_events_, query, output);
 }
 
@@ skipping 143 matching lines @@
   size_t count = 0u;
   for (size_t i = begin_position; i < end_position; ++i) {
     if (query.Evaluate(*events.at(i)))
       ++count;
   }
   return count;
 }
 
 }  // namespace trace_analyzer