Add some changes to TraceAnalyzer to improve analysis

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::trace_event::TraceLog.
 // - Create TraceAnalyzer with JSON string.
@@ skipping 156 matching lines @@
   std::string id;
 
   // All numbers and bool values from TraceEvent args are cast to double.
   // bool becomes 1.0 (true) or 0.0 (false).
   std::map<std::string, double> arg_numbers;
   std::map<std::string, std::string> arg_strings;
   std::map<std::string, std::unique_ptr<base::Value>> arg_values;
 
   // The other event associated with this event (or NULL).
   const TraceEvent* other_event;
+
+  // A back-link for |other_event|. That is, if other_event is not null, then
+  // |event->other_event->prev_event == event| is always true.
+  const TraceEvent* prev_event;
 };
 
 typedef std::vector<const TraceEvent*> TraceEventVector;
 
 class Query {
  public:
   Query(const Query& query);
 
   ~Query();
 
@@ skipping 157 matching lines @@
   // Number arguments include types double, int and bool.
   static Query OtherHasNumberArg(const std::string& arg_name) {
     return Query(OTHER_HAS_NUMBER_ARG, arg_name);
   }
 
   // Evaluates to arg value (string or number).
   static Query OtherArg(const std::string& arg_name) {
     return Query(OTHER_ARG, arg_name);
   }
 
+  // Access the associated prev_event's members:
+
+  static Query PrevPid() { return Query(PREV_PID); }
+
+  static Query PrevTid() { return Query(PREV_TID); }
+
+  static Query PrevTime() { return Query(PREV_TIME); }
+
+  static Query PrevPhase() { return Query(PREV_PHASE); }
+
+  static Query PrevCategory() { return Query(PREV_CATEGORY); }
+
+  static Query PrevName() { return Query(PREV_NAME); }
+
+  static Query PrevId() { return Query(PREV_ID); }
+
+  static Query PrevPidIs(int process_id) {
+    return Query(PREV_PID) == Query::Int(process_id);
+  }
+
+  static Query PrevTidIs(int thread_id) {
+    return Query(PREV_TID) == Query::Int(thread_id);
+  }
+
+  static Query PrevThreadIs(const TraceEvent::ProcessThreadID& thread) {
+    return PrevPidIs(thread.process_id) && PrevTidIs(thread.thread_id);
+  }
+
+  static Query PrevTimeIs(double timestamp) {
+    return Query(PREV_TIME) == Query::Double(timestamp);
+  }
+
+  static Query PrevPhaseIs(char phase) {
+    return Query(PREV_PHASE) == Query::Phase(phase);
+  }
+
+  static Query PrevCategoryIs(const std::string& category) {
+    return Query(PREV_CATEGORY) == Query::String(category);
+  }
+
+  static Query PrevNameIs(const std::string& name) {
+    return Query(PREV_NAME) == Query::String(name);
+  }
+
+  static Query PrevIdIs(const std::string& id) {
+    return Query(PREV_ID) == Query::String(id);
+  }
+
+  // Evaluates to true if arg exists and is a string.
+  static Query PrevHasStringArg(const std::string& arg_name) {
+    return Query(PREV_HAS_STRING_ARG, arg_name);
+  }
+
+  // Evaluates to true if arg exists and is a number.
+  // Number arguments include types double, int and bool.
+  static Query PrevHasNumberArg(const std::string& arg_name) {
+    return Query(PREV_HAS_NUMBER_ARG, arg_name);
+  }
+
+  // Evaluates to arg value (string or number).
+  static Query PrevArg(const std::string& arg_name) {
+    return Query(PREV_ARG, arg_name);
+  }
+
   ////////////////////////////////////////////////////////////////
   // 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 COMPLETE events.
@@ skipping 67 matching lines @@
     EVENT_DURATION,
     EVENT_COMPLETE_DURATION,
     EVENT_PHASE,
     EVENT_CATEGORY,
     EVENT_NAME,
     EVENT_ID,
     EVENT_HAS_STRING_ARG,
     EVENT_HAS_NUMBER_ARG,
     EVENT_ARG,
     EVENT_HAS_OTHER,
+    EVENT_HAS_PREV,
+
     OTHER_PID,
     OTHER_TID,
     OTHER_TIME,
     OTHER_PHASE,
     OTHER_CATEGORY,
     OTHER_NAME,
     OTHER_ID,
     OTHER_HAS_STRING_ARG,
     OTHER_HAS_NUMBER_ARG,
     OTHER_ARG,
+
+    PREV_PID,
+    PREV_TID,
+    PREV_TIME,
+    PREV_PHASE,
+    PREV_CATEGORY,
+    PREV_NAME,
+    PREV_ID,
+    PREV_HAS_STRING_ARG,
+    PREV_HAS_NUMBER_ARG,
+    PREV_ARG,
+
+    OTHER_FIRST_MEMBER = OTHER_PID,
+    OTHER_LAST_MEMBER = OTHER_ARG,
+
+    PREV_FIRST_MEMBER = PREV_PID,
+    PREV_LAST_MEMBER = PREV_ARG,
   };
 
   enum Operator {
     OP_INVALID,
     // Boolean operators:
     OP_EQ,
     OP_NE,
     OP_LT,
     OP_LE,
     OP_GT,
@@ skipping 68 matching lines @@
   bool is_value() const { return type_ != QUERY_BOOLEAN_OPERATOR; }
 
   bool is_unary_operator() const {
     return operator_ == OP_NOT || operator_ == OP_NEGATE;
   }
 
   bool is_comparison_operator() const {
     return operator_ != OP_INVALID && operator_ < OP_AND;
   }
 
+  static const TraceEvent* SelectTargetEvent(const TraceEvent* ev,
+                                             TraceEventMember member);
+
   const Query& left() const;
   const Query& right() const;
 
   QueryType type_;
   Operator operator_;
   scoped_refptr<QueryNode> left_;
   scoped_refptr<QueryNode> right_;
   TraceEventMember member_;
   double number_;
   std::string string_;
@@ skipping 33 matching lines @@
   // 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. 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 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();
+  // |match_pid| - If true, will only match async events which are running
+  //               under the same process ID, otherwise will allow linking
+  //               async events from different processes.
+  void AssociateAsyncBeginEndEvents(bool match_pid = true);
 
   // 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.
@@ skipping 105 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_