Add some changes to TraceAnalyzer to improve analysis

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 <math.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 431 matching lines @@
     case QUERY_EVENT_MEMBER:
       return GetMemberValueAsString(event, str);
     case QUERY_STRING:
       *str = string_;
       return true;
     default:
       return false;
   }
 }
 
+const TraceEvent* Query::SelectTargetEvent(const TraceEvent* event,
+                                           TraceEventMember member) {
+  if (member >= OTHER_FIRST_MEMBER && member <= OTHER_LAST_MEMBER) {
+    return event->other_event;
+  } else if (member >= PREV_FIRST_MEMBER && member <= PREV_LAST_MEMBER) {
+    return event->prev_event;
+  } else {
+    return event;
+  }
+}
+
 bool Query::GetMemberValueAsDouble(const TraceEvent& event,
                                    double* num) const {
   DCHECK_EQ(QUERY_EVENT_MEMBER, type_);
 
   // This could be a request for a member of |event| or a member of |event|'s
-  // associated event. Store the target event in the_event:
-  const TraceEvent* the_event = (member_ < OTHER_PID) ?
-      &event : event.other_event;
+  // associated previous or next event. Store the target event in the_event:
+  const TraceEvent* the_event = SelectTargetEvent(&event, member_);
 
   // Request for member of associated event, but there is no associated event.
   if (!the_event)
     return false;
 
   switch (member_) {
     case EVENT_PID:
     case OTHER_PID:
+    case PREV_PID:
       *num = static_cast<double>(the_event->thread.process_id);
       return true;
     case EVENT_TID:
     case OTHER_TID:
+    case PREV_TID:
       *num = static_cast<double>(the_event->thread.thread_id);
       return true;
     case EVENT_TIME:
     case OTHER_TIME:
+    case PREV_TIME:
       *num = the_event->timestamp;
       return true;
     case EVENT_DURATION:
       if (!the_event->has_other_event())
         return false;
       *num = the_event->GetAbsTimeToOtherEvent();
       return true;
     case EVENT_COMPLETE_DURATION:
       if (the_event->phase != TRACE_EVENT_PHASE_COMPLETE)
         return false;
       *num = the_event->duration;
       return true;
     case EVENT_PHASE:
     case OTHER_PHASE:
+    case PREV_PHASE:
       *num = static_cast<double>(the_event->phase);
       return true;
     case EVENT_HAS_STRING_ARG:
     case OTHER_HAS_STRING_ARG:
+    case PREV_HAS_STRING_ARG:
       *num = (the_event->HasStringArg(string_) ? 1.0 : 0.0);
       return true;
     case EVENT_HAS_NUMBER_ARG:
     case OTHER_HAS_NUMBER_ARG:
+    case PREV_HAS_NUMBER_ARG:
       *num = (the_event->HasNumberArg(string_) ? 1.0 : 0.0);
       return true;
     case EVENT_ARG:
-    case OTHER_ARG: {
+    case OTHER_ARG:
+    case PREV_ARG: {
       // Search for the argument name and return its value if found.
       std::map<std::string, double>::const_iterator num_i =
           the_event->arg_numbers.find(string_);
       if (num_i == the_event->arg_numbers.end())
         return false;
       *num = num_i->second;
       return true;
     }
     case EVENT_HAS_OTHER:
       // return 1.0 (true) if the other event exists
       *num = event.other_event ? 1.0 : 0.0;
       return true;
+    case EVENT_HAS_PREV:
+      *num = event.prev_event ? 1.0 : 0.0;
+      return true;
     default:
       return false;
   }
 }
 
 bool Query::GetMemberValueAsString(const TraceEvent& event,
                                    std::string* str) const {
   DCHECK_EQ(QUERY_EVENT_MEMBER, type_);
 
   // This could be a request for a member of |event| or a member of |event|'s
-  // associated event. Store the target event in the_event:
-  const TraceEvent* the_event = (member_ < OTHER_PID) ?
-      &event : event.other_event;
+  // associated previous or next event. Store the target event in the_event:
+  const TraceEvent* the_event = SelectTargetEvent(&event, member_);
 
   // Request for member of associated event, but there is no associated event.
   if (!the_event)
     return false;
 
   switch (member_) {
     case EVENT_CATEGORY:
     case OTHER_CATEGORY:
+    case PREV_CATEGORY:
       *str = the_event->category;
       return true;
     case EVENT_NAME:
     case OTHER_NAME:
+    case PREV_NAME:
       *str = the_event->name;
       return true;
     case EVENT_ID:
     case OTHER_ID:
+    case PREV_ID:
       *str = the_event->id;
       return true;
     case EVENT_ARG:
-    case OTHER_ARG: {
+    case OTHER_ARG:
+    case PREV_ARG: {
       // Search for the argument name and return its value if found.
       std::map<std::string, std::string>::const_iterator str_i =
           the_event->arg_strings.find(string_);
       if (str_i == the_event->arg_strings.end())
         return false;
       *str = str_i->second;
       return true;
     }
     default:
       return false;
@@ skipping 176 matching lines @@
   Query begin(Query::EventPhaseIs(TRACE_EVENT_PHASE_BEGIN));
   Query end(Query::EventPhaseIs(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::AssociateAsyncBeginEndEvents() {
+void TraceAnalyzer::AssociateAsyncBeginEndEvents(bool match_pid) {
   using trace_analyzer::Query;
 
   Query begin(
       Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_BEGIN) ||
       Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_STEP_INTO) ||
       Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_STEP_PAST));
   Query end(Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_END) ||
             Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_STEP_INTO) ||
             Query::EventPhaseIs(TRACE_EVENT_PHASE_ASYNC_STEP_PAST));
-  Query match(Query::EventName() == Query::OtherName() &&
-              Query::EventCategory() == Query::OtherCategory() &&
+  Query match(Query::EventCategory() == Query::OtherCategory() &&
               Query::EventId() == Query::OtherId());
 
+  if (match_pid) {
+    match = match && Query::EventPid() == Query::OtherPid();
+  }
+
   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 (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 the associated previous event
+          this_event.prev_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
@@ skipping 195 matching lines @@
   end_position = (end_position < events.size()) ? end_position : events.size();
   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