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 84 matching lines @@
 #define BASE_DEBUG_TRACE_EVENT_H_
 #pragma once
 
 #include "build/build_config.h"
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/hash_tables.h"
+#include "base/memory/ref_counted_memory.h"
 #include "base/memory/singleton.h"
 #include "base/string_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/timer.h"
 
 // By default, const char* argument values are assumed to have long-lived scope
 // and will not be copied. Use this macro to force a const char* to be copied.
 #define TRACE_STR_COPY(str) base::debug::TraceValue::StringWithCopy(str)
 
 // Older style trace macros with explicit id and extra data
@@ skipping 297 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_;
 };
 
 // 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 {
+class BASE_EXPORT TraceEvent {
  public:
   TraceEvent();
   TraceEvent(unsigned long process_id,
              unsigned long thread_id,
              TimeTicks timestamp,
              TraceEventPhase phase,
              const TraceCategory* category,
              const char* name,
              const char* arg1_name, const TraceValue& arg1_val,
              const char* arg2_name, const TraceValue& arg2_val,
              bool copy);
   ~TraceEvent();
 
+  static const char* GetPhaseString(TraceEventPhase phase);
+  static TraceEventPhase GetPhase(const char* phase);
+
   // Serialize event data to JSON
   static void AppendEventsAsJSON(const std::vector<TraceEvent>& events,
                                  size_t start,
                                  size_t count,
                                  std::string* out);
   void AppendAsJSON(std::string* out) const;
 
   TimeTicks timestamp() const { return timestamp_; }
 
   // Exposed for unittesting:
@@ skipping 246 matching lines @@
   Data* p_data_;
   Data data_;
 };
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_H_