Add some TraceAnalyzer utility methods to simplify test code

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 197 matching lines @@
   static Query EventDuration() { return Query(EVENT_DURATION); }
 
   static Query EventPhase() { return Query(EVENT_PHASE); }
 
   static Query EventCategory() { return Query(EVENT_CATEGORY); }
 
   static Query EventName() { return Query(EVENT_NAME); }
 
   static Query EventId() { return Query(EVENT_ID); }
 
+  static Query EventPidIs(int process_id) {
+    return Query(EVENT_PID) == Query::Int(process_id);
+  }
+
+  static Query EventTidIs(int thread_id) {
+    return Query(EVENT_TID) == Query::Int(thread_id);
+  }
+
+  static Query EventThreadIs(const TraceEvent::ProcessThreadID& thread) {
+    return EventPidIs(thread.process_id) && EventTidIs(thread.thread_id);
+  }
+
+  static Query EventTimeIs(double timestamp) {
+    return Query(EVENT_TIME) == Query::Double(timestamp);
+  }
+
+  static Query EventDurationIs(double duration) {
+    return Query(EVENT_DURATION) == Query::Double(duration);
+  }
+
+  static Query EventPhaseIs(char phase) {
+    return Query(EVENT_PHASE) == Query::Phase(phase);
+  }
+
+  static Query EventCategoryIs(const std::string& category) {
+    return Query(EVENT_CATEGORY) == Query::String(category);
+  }
+
+  static Query EventNameIs(const std::string& name) {
+    return Query(EVENT_NAME) == Query::String(name);
+  }
+
+  static Query EventIdIs(const std::string& id) {
+    return Query(EVENT_ID) == Query::String(id);
+  }
+
   // Evaluates to true if arg exists and is a string.
   static Query EventHasStringArg(const std::string& arg_name) {
     return Query(EVENT_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 EventHasNumberArg(const std::string& arg_name) {
     return Query(EVENT_HAS_NUMBER_ARG, arg_name);
   }
@@ skipping 15 matching lines @@
   static Query OtherTime() { return Query(OTHER_TIME); }
 
   static Query OtherPhase() { return Query(OTHER_PHASE); }
 
   static Query OtherCategory() { return Query(OTHER_CATEGORY); }
 
   static Query OtherName() { return Query(OTHER_NAME); }
 
   static Query OtherId() { return Query(OTHER_ID); }
 
+  static Query OtherPidIs(int process_id) {
+    return Query(OTHER_PID) == Query::Int(process_id);
+  }
+
+  static Query OtherTidIs(int thread_id) {
+    return Query(OTHER_TID) == Query::Int(thread_id);
+  }
+
+  static Query OtherThreadIs(const TraceEvent::ProcessThreadID& thread) {
+    return OtherPidIs(thread.process_id) && OtherTidIs(thread.thread_id);
+  }
+
+  static Query OtherTimeIs(double timestamp) {
+    return Query(OTHER_TIME) == Query::Double(timestamp);
+  }
+
+  static Query OtherPhaseIs(char phase) {
+    return Query(OTHER_PHASE) == Query::Phase(phase);
+  }
+
+  static Query OtherCategoryIs(const std::string& category) {
+    return Query(OTHER_CATEGORY) == Query::String(category);
+  }
+
+  static Query OtherNameIs(const std::string& name) {
+    return Query(OTHER_NAME) == Query::String(name);
+  }
+
+  static Query OtherIdIs(const std::string& id) {
+    return Query(OTHER_ID) == Query::String(id);
+  }
+
+  // Evaluates to true if arg exists and is a string.
   static Query OtherHasStringArg(const std::string& arg_name) {
     return Query(OTHER_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 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);
   }
 
   ////////////////////////////////////////////////////////////////
   // Common queries:
 
   // Find BEGIN events that have a corresponding END event.
   static Query MatchBeginWithEnd() {
     return (Query(EVENT_PHASE) == Query::Phase(TRACE_EVENT_PHASE_BEGIN)) &&
@@ skipping 231 matching lines @@
   //            should evaluate to true if the |first|/|second| pair is a match.
   //
   // 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.
+  // After calling any Find* method, it is not allowed to call AssociateEvents
+  // again.
   void AssociateEvents(const Query& first,
                        const Query& second,
                        const Query& match);
 
   // For each event, copy its arguments to the other_event argument map. If
   // argument name already exists, it will not be overwritten.
   void MergeAssociatedEventArgs();
 
   // Find all events that match query and replace output vector.
   size_t FindEvents(const Query& query, TraceEventVector* output);
 
-  // Helper method: find first event that matches query
-  const TraceEvent* FindOneEvent(const Query& query);
+  // Find first event that matches query or NULL if not found.
+  const TraceEvent* FindFirstOf(const Query& query);
+
+  // Find last event that matches query or NULL if not found.
+  const TraceEvent* FindLastOf(const Query& query);
 
   const std::string& GetThreadName(const TraceEvent::ProcessThreadID& thread);
 
  private:
   TraceAnalyzer();
 
   bool SetEvents(const std::string& json_events) WARN_UNUSED_RESULT;
 
   // Read metadata (thread names, etc) from events.
   void ParseMetadata();
@@ skipping 63 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_