Add a ConvertableToTraceFormat type to the trace framework.

base/debug/trace_event.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.
 
 // This header file defines the set of trace_event macros without specifying
 // how the events actually get collected and stored. If you need to expose trace
 // events to some other universe, you can copy-and-paste this file as well as
 // trace_event.h, modifying the macros contained there as necessary for the
 // target platform. The end result is that multiple libraries can funnel events
 // through to a shared trace event collector.
@@ skipping 105 matching lines @@
 //     TRACE_EVENT1("category", "name",
 //                  "arg1", "literal string is only referenced");
 // Use TRACE_STR_COPY to force copying of a const char*:
 //     TRACE_EVENT1("category", "name",
 //                  "arg1", TRACE_STR_COPY("string will be copied"));
 // std::string arg_values are always copied:
 //     TRACE_EVENT1("category", "name",
 //                  "arg1", std::string("string will be copied"));
 //
 //
+// Convertable notes:
+// Converting a large data type to a string can be costly. To help with this,
+// the trace framework provides an interface ConvertableToTraceFormat. If you
+// inherit from it and implement the AppendAsTraceFormat method the trace
+// framework will call back to your object to convert a trace output time. This
+// means, if the category for the event is disabled, the conversion will not
+// happen.
+//
+//   class MyData : public base::debug::ConvertableToTraceFormat {
+//    public:
+//     MyData() {}
+//     virtual ~MyData() {}
+//     virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
+//       out->append("{\"foo\":1}");
+//     }
+//    private:
+//     DISALLOW_COPY_AND_ASSIGN(MyData);
+//   };
+//
+//   scoped_ptr<MyData> data(new MyData());
+//   TRACE_EVENT1("foo", "bar", "data",
+//                data.PassAs<base::debug::ConvertableToTraceFormat>());
+//
+// The trace framework will take ownership if the passed pointer and it will
+// be free'd when the trace buffer is flushed.
+//
+// Note, we only do the conversion when the buffer is flushed, so the provided
+// data object should not be modified after it's passed to the trace framework.
+//
+//
 // Thread Safety:
 // A thread safe singleton and mutex are used for thread safety. Category
 // enabled flags are used to limit the performance impact when the system
 // is not enabled.
 //
 // TRACE_EVENT macros first cache a pointer to a category. The categories are
 // statically allocated and safe at all times, even after exit. Fetching a
 // category is protected by the TraceLog::lock_. Multiple threads initializing
 // the static variable is safe, as they will be serialized by the lock and
 // multiple calls will return the same pointer to the category.
@@ skipping 656 matching lines @@
     TRACE_EVENT_FLAG_SCOPE_OFFSET | (TRACE_EVENT_FLAG_SCOPE_OFFSET << 1)))
 
 // Type values for identifying types in the TraceValue union.
 #define TRACE_VALUE_TYPE_BOOL         (static_cast<unsigned char>(1))
 #define TRACE_VALUE_TYPE_UINT         (static_cast<unsigned char>(2))
 #define TRACE_VALUE_TYPE_INT          (static_cast<unsigned char>(3))
 #define TRACE_VALUE_TYPE_DOUBLE       (static_cast<unsigned char>(4))
 #define TRACE_VALUE_TYPE_POINTER      (static_cast<unsigned char>(5))
 #define TRACE_VALUE_TYPE_STRING       (static_cast<unsigned char>(6))
 #define TRACE_VALUE_TYPE_COPY_STRING  (static_cast<unsigned char>(7))
+#define TRACE_VALUE_TYPE_CONVERTABLE  (static_cast<unsigned char>(8))
 
 // Enum reflecting the scope of an INSTANT event. Must fit within
 // TRACE_EVENT_FLAG_SCOPE_MASK.
 #define TRACE_EVENT_SCOPE_GLOBAL  (static_cast<unsigned char>(0 << 3))
 #define TRACE_EVENT_SCOPE_PROCESS (static_cast<unsigned char>(1 << 3))
 #define TRACE_EVENT_SCOPE_THREAD  (static_cast<unsigned char>(2 << 3))
 
 #define TRACE_EVENT_SCOPE_NAME_GLOBAL  ('g')
 #define TRACE_EVENT_SCOPE_NAME_PROCESS ('p')
 #define TRACE_EVENT_SCOPE_NAME_THREAD  ('t')
@@ skipping 87 matching lines @@
  private:
   const char* str_;
 };
 
 // Define SetTraceValue for each allowed type. It stores the type and
 // value in the return arguments. This allows this API to avoid declaring any
 // structures so that it is portable to third_party libraries.
 #define INTERNAL_DECLARE_SET_TRACE_VALUE(actual_type, \
                                          union_member, \
                                          value_type_id) \
-    static inline void SetTraceValue(actual_type arg, \
-                                     unsigned char* type, \
-                                     unsigned long long* value) { \
+    static inline void SetTraceValue( \
+        actual_type arg, \
+        unsigned char* type, \
+        unsigned long long* value) { \
       TraceValueUnion type_value; \
       type_value.union_member = arg; \
       *type = value_type_id; \
       *value = type_value.as_uint; \
     }
 // Simpler form for int types that can be safely casted.
 #define INTERNAL_DECLARE_SET_TRACE_VALUE_INT(actual_type, \
                                              value_type_id) \
-    static inline void SetTraceValue(actual_type arg, \
-                                     unsigned char* type, \
-                                     unsigned long long* value) { \
+    static inline void SetTraceValue( \
+        actual_type arg, \
+        unsigned char* type, \
+        unsigned long long* value) { \
       *type = value_type_id; \
       *value = static_cast<unsigned long long>(arg); \
     }
 
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned long long, TRACE_VALUE_TYPE_UINT)
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned long, TRACE_VALUE_TYPE_UINT)
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned int, TRACE_VALUE_TYPE_UINT)
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned short, TRACE_VALUE_TYPE_UINT)
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned char, TRACE_VALUE_TYPE_UINT)
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(long long, TRACE_VALUE_TYPE_INT)
@@ skipping 29 matching lines @@
 // pointers to the internal c_str and pass through to the tracing API,
 // the arg_values must live throughout these procedures.
 
 static inline void AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TimeTicks& timestamp,
+    unsigned char flags,
+    const char* arg1_name,
+    scoped_ptr<base::debug::ConvertableToTraceFormat> arg1_val) {
+  const int num_args = 1;
+  unsigned char arg_types[1] = { TRACE_VALUE_TYPE_CONVERTABLE };
+  scoped_ptr<base::debug::ConvertableToTraceFormat> convertable_values[1];
+  convertable_values[0].reset(arg1_val.release());
+
+  TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
+      phase, category_enabled, name, id, thread_id, timestamp,
+      num_args, &arg1_name, arg_types, NULL, convertable_values, flags);
+}
+
+static inline void AddTraceEvent(
+    char phase,
+    const unsigned char* category_enabled,
+    const char* name,
+    unsigned long long id,
+    unsigned char flags,
+    const char* arg1_name,
+    scoped_ptr<base::debug::ConvertableToTraceFormat> arg1_val) {
+  int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
+  base::TimeTicks now = base::TimeTicks::NowFromSystemTraceTime();
+  AddTraceEventWithThreadIdAndTimestamp(phase, category_enabled, name, id,
+                                        thread_id, now, flags, arg1_name,
+                                        arg1_val.Pass());
+}
+
+static inline void AddTraceEventWithThreadIdAndTimestamp(
+    char phase,
+    const unsigned char* category_enabled,
+    const char* name,
+    unsigned long long id,
+    int thread_id,
+    const base::TimeTicks& timestamp,
+    unsigned char flags,
+    const char* arg1_name,
+    scoped_ptr<base::debug::ConvertableToTraceFormat> arg1_val,
+    const char* arg2_name,
+    scoped_ptr<base::debug::ConvertableToTraceFormat> arg2_val) {
+  const int num_args = 2;
+  unsigned char arg_types[2] =
+      { TRACE_VALUE_TYPE_CONVERTABLE, TRACE_VALUE_TYPE_CONVERTABLE };
+  scoped_ptr<base::debug::ConvertableToTraceFormat> convertable_values[2];
+  convertable_values[0].reset(arg1_val.release());
+  convertable_values[1].reset(arg2_val.release());
+
+  TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
+      phase, category_enabled, name, id, thread_id, timestamp,
+      num_args, &arg1_name, arg_types, NULL, convertable_values, flags);
+}
+
+static inline void AddTraceEvent(
+    char phase,
+    const unsigned char* category_enabled,
+    const char* name,
+    unsigned long long id,
+    unsigned char flags,
+    const char* arg1_name,
+    scoped_ptr<base::debug::ConvertableToTraceFormat> arg1_val,
+    const char* arg2_name,
+    scoped_ptr<base::debug::ConvertableToTraceFormat> arg2_val) {
+  int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
+  base::TimeTicks now = base::TimeTicks::NowFromSystemTraceTime();
+  AddTraceEventWithThreadIdAndTimestamp(phase, category_enabled, name, id,
+                                        thread_id, now, flags,
+                                        arg1_name, arg1_val.Pass(),
+                                        arg2_name, arg2_val.Pass());
+}
+
+static inline void AddTraceEventWithThreadIdAndTimestamp(
+    char phase,
+    const unsigned char* category_enabled,
+    const char* name,
+    unsigned long long id,
+    int thread_id,
+    const base::TimeTicks& timestamp,
     unsigned char flags) {
   TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
       phase, category_enabled, name, id, thread_id, timestamp,
-      kZeroNumArgs, NULL, NULL, NULL, flags);
+      kZeroNumArgs, NULL, NULL, NULL, NULL, flags);
 }
 
 static inline void AddTraceEvent(char phase,
                                  const unsigned char* category_enabled,
                                  const char* name,
                                  unsigned long long id,
                                  unsigned char flags) {
   int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
   base::TimeTicks now = base::TimeTicks::NowFromSystemTraceTime();
   AddTraceEventWithThreadIdAndTimestamp(phase, category_enabled, name, id,
@@ skipping 10 matching lines @@
     const base::TimeTicks& timestamp,
     unsigned char flags,
     const char* arg1_name,
     const ARG1_TYPE& arg1_val) {
   const int num_args = 1;
   unsigned char arg_types[1];
   unsigned long long arg_values[1];
   SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
   TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
       phase, category_enabled, name, id, thread_id, timestamp,
-      num_args, &arg1_name, arg_types, arg_values, flags);
+      num_args, &arg1_name, arg_types, arg_values, NULL, flags);
 }
 
 template<class ARG1_TYPE>
 static inline void AddTraceEvent(char phase,
                                  const unsigned char* category_enabled,
                                  const char* name,
                                  unsigned long long id,
                                  unsigned char flags,
                                  const char* arg1_name,
                                  const ARG1_TYPE& arg1_val) {
@@ skipping 18 matching lines @@
     const char* arg2_name,
     const ARG2_TYPE& arg2_val) {
   const int num_args = 2;
   const char* arg_names[2] = { arg1_name, arg2_name };
   unsigned char arg_types[2];
   unsigned long long arg_values[2];
   SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
   SetTraceValue(arg2_val, &arg_types[1], &arg_values[1]);
   TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
       phase, category_enabled, name, id, thread_id, timestamp,
-      num_args, arg_names, arg_types, arg_values, flags);
+      num_args, arg_names, arg_types, arg_values, NULL, flags);
 }
 
 template<class ARG1_TYPE, class ARG2_TYPE>
 static inline void AddTraceEvent(char phase,
                                 const unsigned char* category_enabled,
                                 const char* name,
                                 unsigned long long id,
                                 unsigned char flags,
                                 const char* arg1_name,
                                 const ARG1_TYPE& arg1_val,
@@ skipping 25 matching lines @@
 
  private:
   // Add the end event if the category is still enabled.
   void AddEventIfEnabled() {
     // Only called when p_data_ is non-null.
     if (*p_data_->category_enabled) {
       TRACE_EVENT_API_ADD_TRACE_EVENT(
           TRACE_EVENT_PHASE_END,
           p_data_->category_enabled,
           p_data_->name, kNoEventId,
-          kZeroNumArgs, NULL, NULL, NULL,
+          kZeroNumArgs, NULL, NULL, NULL, NULL,
           TRACE_EVENT_FLAG_NONE);
     }
   }
 
   // This Data struct workaround is to avoid initializing all the members
   // in Data during construction of this object, since this object is always
   // constructed, even when tracing is disabled. If the members of Data were
   // members of this class instead, compiler warnings occur about potential
   // uninitialized accesses.
   struct Data {
@@ skipping 53 matching lines @@
   const char* name_;
   IDType id_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
 };
 
 } // namespace debug
 } // namespace base
 
 #endif /* BASE_DEBUG_TRACE_EVENT_H_ */