Add TraceAnalyzer support for START/FINISH events and JSON error logging

base/test/trace_event_analyzer.h

 // Copyright (c) 2011 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 140 matching lines @@
   // Time since epoch in microseconds.
   // Stored as double to match its JSON representation.
   double timestamp;
 
   base::debug::TraceEventPhase phase;
 
   std::string category;
 
   std::string name;
 
+  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;
 
   // The other event associated with this event (or NULL).
   const TraceEvent* other_event;
 };
 
 // Pass these values to Query to compare with the corresponding member of a
 // TraceEvent. Unless otherwise specfied, the usage is Query(ENUM_MEMBER).
 enum TraceEventMember {
   EVENT_INVALID,
   // Use these to access the event members:
   EVENT_PID,
   EVENT_TID,
   // Return the timestamp of the event in microseconds since epoch.
   EVENT_TIME,
   // Return the absolute time between event and other event in microseconds.
   // Only works for events with associated BEGIN/END: Query(EVENT_HAS_OTHER).
   EVENT_DURATION,
   EVENT_PHASE,
   EVENT_CATEGORY,
   EVENT_NAME,
+  EVENT_ID,
 
   // Evaluates to true if arg exists and is a string.
   // Usage: Query(EVENT_HAS_STRING_ARG, "arg_name")
   EVENT_HAS_STRING_ARG,
   // Evaluates to true if arg exists and is a number.
   // Number arguments include types double, int and bool.
   // Usage: Query(EVENT_HAS_NUMBER_ARG, "arg_name")
   EVENT_HAS_NUMBER_ARG,
   // Evaluates to arg value (string or number).
   // Usage: Query(EVENT_ARG, "arg_name")
   EVENT_ARG,
   // Return true if associated event exists.
   // (Typically BEGIN for END or END for BEGIN).
   EVENT_HAS_OTHER,
 
   // Access the associated other_event's members:
   OTHER_PID,
   OTHER_TID,
   OTHER_TIME,
   OTHER_PHASE,
   OTHER_CATEGORY,
   OTHER_NAME,
+  OTHER_ID,
 
   // Evaluates to true if arg exists and is a string.
   // Usage: Query(EVENT_HAS_STRING_ARG, "arg_name")
   OTHER_HAS_STRING_ARG,
   // Evaluates to true if arg exists and is a number.
   // Number arguments include types double, int and bool.
   // Usage: Query(EVENT_HAS_NUMBER_ARG, "arg_name")
   OTHER_HAS_NUMBER_ARG,
   // Evaluates to arg value (string or number).
   // Usage: Query(EVENT_ARG, "arg_name")
@@ skipping 27 matching lines @@
   static Query Phase(base::debug::TraceEventPhase phase);
 
   // Compare with the given string pattern. Only works with == and != operators.
   // Example: Query(EVENT_NAME) == Query::Pattern("MyEvent*")
   static Query Pattern(const std::string& pattern);
 
   // Common queries:
 
   // Find BEGIN events that have a corresponding END event.
   static Query MatchBeginWithEnd() {
-    return (Query(EVENT_PHASE) ==
-            Query::Phase(TRACE_EVENT_PHASE_BEGIN)) &&
+    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)) &&
+           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) {
     return (Query(EVENT_PID) == Query::Int(thread.process_id)) &&
            (Query(EVENT_TID) == Query::Int(thread.thread_id));
   }
@@ skipping 148 matching lines @@
   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.
   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();
+
   // 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.
@@ skipping 34 matching lines @@
   std::map<TraceEvent::ProcessThreadID, std::string> thread_names_;
   std::vector<TraceEvent> raw_events_;
   bool allow_assocation_changes_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceAnalyzer);
 };
 
 }  // namespace trace_analyzer
 
 #endif  // BASE_TEST_TRACE_EVENT_ANALYZER_H_