Add a ConvertableToTraceFormat type to the trace framework.

base/debug/trace_event_impl.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.
 
 
 #ifndef BASE_DEBUG_TRACE_EVENT_IMPL_H_
 #define BASE_DEBUG_TRACE_EVENT_IMPL_H_
 
 #include <string>
 #include <vector>
@@ skipping 28 matching lines @@
 
 template <typename Type>
 struct StaticMemorySingletonTraits;
 
 namespace base {
 
 class WaitableEvent;
 
 namespace debug {
 
+// For any argument of type TRACE_VALUE_TYPE_CONVERTABLE the provided
+// class must implement this interface.
+class ConvertableToJSON {

[nduca, 2013/04/09 22:16:42]

So lets call this ConvertableToTraceFormat or something like that that more
clearly states that this is tracing specific, not something that is to be used
for other people using JSON/value types.

[dsinclair, 2013/04/10 01:09:31]

Done.

+ public:
+   virtual ~ConvertableToJSON() {}
+
+  // Append the JSONified class info to the provided |out| string. The appended
+  // data must be a valid JSON object. Strings must be propertly quoted, and
+  // escaped. There is no processing applied to the content after it is
+  // appended.
+  virtual void ToJSON(std::string& out) const = 0;

[nduca, 2013/04/09 22:16:42]

Should this use the word Append somehow?

[dsinclair, 2013/04/10 01:09:31]

Done.

+};
+
 const int kTraceMaxNumArgs = 2;
 
 // 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 BASE_EXPORT TraceEvent {
  public:
   union TraceValue {
     bool as_bool;
     unsigned long long as_uint;
     long long as_int;
     double as_double;
     const void* as_pointer;
     const char* as_string;
   };
 
   TraceEvent();
   TraceEvent(int thread_id,
              TimeTicks timestamp,
              char phase,
              const unsigned char* category_enabled,
              const char* name,
              unsigned long long id,
              int num_args,
              const char** arg_names,
              const unsigned char* arg_types,
              const unsigned long long* arg_values,
+             scoped_ptr<ConvertableToJSON> convertable_values[],
              unsigned char flags);
+  TraceEvent(const TraceEvent& other);
+  TraceEvent& operator=(const TraceEvent& other);
   ~TraceEvent();
 
   // 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;
 
   static void AppendValueAsJSON(unsigned char type,
@@ skipping 11 matching lines @@
   const unsigned char* category_enabled() const { return category_enabled_; }
   const char* name() const { return name_; }
 
  private:
   // Note: these are ordered by size (largest first) for optimal packing.
   TimeTicks timestamp_;
   // id_ can be used to store phase-specific data.
   unsigned long long id_;
   TraceValue arg_values_[kTraceMaxNumArgs];
   const char* arg_names_[kTraceMaxNumArgs];
+  scoped_ptr<ConvertableToJSON> convertable_values_[kTraceMaxNumArgs];
   const unsigned char* category_enabled_;
   const char* name_;
   scoped_refptr<base::RefCountedString> parameter_copy_storage_;

[nduca, 2013/04/09 22:16:42]

we can remove this in a followup

[dsinclair, 2013/04/10 01:09:31]

Ack.

   int thread_id_;
   char phase_;
   unsigned char flags_;
   unsigned char arg_types_[kTraceMaxNumArgs];
 };
 
 // TraceBuffer holds the events as they are collected.
 class BASE_EXPORT TraceBuffer {
  public:
   virtual ~TraceBuffer() {}
@@ skipping 189 matching lines @@
   // If |copy| is set, |name|, |arg_name1| and |arg_name2| will be deep copied
   // into the event; see "Memory scoping note" and TRACE_EVENT_COPY_XXX above.
   void AddTraceEvent(char phase,
                      const unsigned char* category_enabled,
                      const char* name,
                      unsigned long long id,
                      int num_args,
                      const char** arg_names,
                      const unsigned char* arg_types,
                      const unsigned long long* arg_values,
+                     scoped_ptr<ConvertableToJSON> convertable_values[],
                      unsigned char flags);
   void AddTraceEventWithThreadIdAndTimestamp(
       char phase,
       const unsigned char* category_enabled,
       const char* name,
       unsigned long long id,
       int thread_id,
       const TimeTicks& timestamp,
       int num_args,
       const char** arg_names,
       const unsigned char* arg_types,
       const unsigned long long* arg_values,
+      scoped_ptr<ConvertableToJSON> convertable_values[],
       unsigned char flags);
   static void AddTraceEventEtw(char phase,
                                const char* name,
                                const void* id,
                                const char* extra);
   static void AddTraceEventEtw(char phase,
                                const char* name,
                                const void* id,
                                const std::string& extra);
 
@@ skipping 122 matching lines @@
   scoped_ptr<TraceSamplingThread> sampling_thread_;
   PlatformThreadHandle sampling_thread_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_IMPL_H_