add classes trace_analyzer::Query and TraceAnalyzer to make it easy to search through trace data

base/debug/trace_event.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.
 
 // Trace events are for tracking application performance.
 //
 // Events are issued against categories. Whereas LOG's
 // categories are statically defined, TRACE categories are created
 // implicitly with a string. For example:
 //   TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent")
@@ skipping 79 matching lines @@
 // ANNOTATE_BENIGN_RACE is used to suppress the warning on the static category
 // pointers.
 
 
 #ifndef BASE_DEBUG_TRACE_EVENT_H_
 #define BASE_DEBUG_TRACE_EVENT_H_
 #pragma once
 
 #include "build/build_config.h"
 
+#include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/hash_tables.h"
 #include "base/memory/singleton.h"
 #include "base/string_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/timer.h"
 
@@ skipping 194 matching lines @@
           name, arg1_name, arg1_val, arg2_name, arg2_val, -1, 0, \
           base::debug::TraceLog::EVENT_FLAG_NONE); \
     INTERNAL_TRACE_EVENT_UID(profileScope).Initialize( \
         INTERNAL_TRACE_EVENT_UID(catstatic), name, \
         INTERNAL_TRACE_EVENT_UID(begin_event_id), threshold); \
   }
 
 namespace base {
 
 class RefCountedString;
+class Value;
 
 namespace debug {
 
 // Categories allow enabling/disabling of streams of trace events
 struct TraceCategory {
   const char* name;
   volatile bool enabled;
 };
 
 const size_t kTraceMaxNumArgs = 2;
@@ skipping 72 matching lines @@
     return value;
   }
 
   static TraceValue ForceCopy(const TraceValue& rhs) {
     TraceValue value(rhs);
     if (value.type_ == TRACE_TYPE_STATIC_STRING && value.as_string())
       value.type_ = TRACE_TYPE_STRING;
     return value;
   }
 
+  bool is_string() const {
+    return type_ == TRACE_TYPE_STRING || type_ == TRACE_TYPE_STATIC_STRING;
+  }
+
   void AppendAsJSON(std::string* out) const;
 
   Type type() const {
     return type_;
   }
   uint64 as_uint() const {
     DCHECK_EQ(TRACE_TYPE_UINT, type_);
     return value_.as_uint;
   }
   bool as_bool() const {
     DCHECK_EQ(TRACE_TYPE_BOOL, type_);
     return value_.as_bool;
   }
   int64 as_int() const {
     DCHECK_EQ(TRACE_TYPE_INT, type_);
     return value_.as_int;
   }
   double as_double() const {
     DCHECK_EQ(TRACE_TYPE_DOUBLE, type_);
     return value_.as_double;
   }
   const void* as_pointer() const {
     DCHECK_EQ(TRACE_TYPE_POINTER, type_);
     return value_.as_pointer;
   }
   const char* as_string() const {
-    DCHECK(type_ == TRACE_TYPE_STRING || type_ == TRACE_TYPE_STATIC_STRING);
+    DCHECK(is_string());
     return value_.as_string;
   }
   const char** as_assignable_string() {
     DCHECK_EQ(TRACE_TYPE_STRING, type_);
     return &value_.as_string;
   }
 
  private:
   union Value {
     bool as_bool;
     uint64 as_uint;
     int64 as_int;
     double as_double;
     const void* as_pointer;
     const char* as_string;
   };
 
   Type type_;
   Value value_;
 };
 
+// TestTraceEvent is a more convenient form of the TraceEvent class to make
+// tracing-based tests easier to write.
+struct TestTraceEvent {

[scheib, 2011/09/29 23:33:56]

This seems to exist to parse trace events into convenient C++ objects. Consider
moving outside of this file to keep trace_event.h simpler?

[jbates, 2011/09/30 21:07:37]

Done.

+  // PidTid contains a Process ID and Thread ID.
+  struct PidTid {
+    PidTid() : pid(0), tid(0) {}
+    PidTid(int pid, int tid) : pid(pid), tid(tid) {}
+    bool operator< (PidTid rhs) const {
+      if (pid != rhs.pid)
+        return pid < rhs.pid;
+      return tid < rhs.tid;
+    }
+    int pid;
+    int tid;
+  };
+
+  TestTraceEvent();
+  TestTraceEvent(const base::Value* event_value);
+  ~TestTraceEvent();
+
+  // Convert JSON string to array of TestTraceEvent.
+  // |output| is appended with the parsed events.
+  static bool ParseEventsFromJson(const std::string& json,
+                                  std::vector<TestTraceEvent>* output);
+
+  bool operator< (const TestTraceEvent& rhs) const {
+    return timestamp < rhs.timestamp;
+  }
+
+  // Returns duration if it's available.
+  bool GetDuration(double* duration) const;
+
+  // Return the argument value if it exists.
+  bool IsArg(const std::string& name) const;
+  // Return the argument value if it exists and it is a string.
+  bool GetArgAsString(const std::string& name, std::string* arg) const;
+  // Return the argument value if it exists and it is a number.
+  bool GetArgAsNumber(const std::string& name, double* arg) const;
+
+  // Called by TraceAnalyzer to associate this event with another event.
+  void set_other_event(const TestTraceEvent* event) {
+    other_event = event;
+  }
+
+  // Process ID and Thread ID.
+  PidTid pid_tid;
+  // Time since epoch in microseconds.
+  // Stored as double to match its JSON representation.
+  double timestamp;
+  TraceEventPhase phase;
+  std::string category;
+  std::string name;
+  // 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 TestTraceEvent* other_event;
+};
+
 // Output records are "Events" and can be obtained via the
 // OutputCallback whenever the tracing system decides to flush. This
 // can happen at any time, on any thread, or you can programatically
 // force it to happen.
 class TraceEvent {
  public:
   TraceEvent();
   TraceEvent(unsigned long process_id,
              unsigned long thread_id,
              TimeTicks timestamp,
@@ skipping 215 matching lines @@
   Data* p_data_;
   Data data_;
 };
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_H_