Add a ConvertableToTraceFormat type to the trace framework.

base/debug/trace_event_internal.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 713 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, \
+        scoped_ptr<base::debug::ConvertableToJSON>* convertable_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, \
+        scoped_ptr<base::debug::ConvertableToJSON>* convertable_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)
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(long, TRACE_VALUE_TYPE_INT)
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(int, TRACE_VALUE_TYPE_INT)
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(short, TRACE_VALUE_TYPE_INT)
 INTERNAL_DECLARE_SET_TRACE_VALUE_INT(signed char, TRACE_VALUE_TYPE_INT)
 INTERNAL_DECLARE_SET_TRACE_VALUE(bool, as_bool, TRACE_VALUE_TYPE_BOOL)
 INTERNAL_DECLARE_SET_TRACE_VALUE(double, as_double, TRACE_VALUE_TYPE_DOUBLE)
 INTERNAL_DECLARE_SET_TRACE_VALUE(const void*, as_pointer,
                                  TRACE_VALUE_TYPE_POINTER)
 INTERNAL_DECLARE_SET_TRACE_VALUE(const char*, as_string,
                                  TRACE_VALUE_TYPE_STRING)
 INTERNAL_DECLARE_SET_TRACE_VALUE(const TraceStringWithCopy&, as_string,
                                  TRACE_VALUE_TYPE_COPY_STRING)
 
 #undef INTERNAL_DECLARE_SET_TRACE_VALUE
 #undef INTERNAL_DECLARE_SET_TRACE_VALUE_INT
 
 // std::string version of SetTraceValue so that trace arguments can be strings.
-static inline void SetTraceValue(const std::string& arg,
-                                 unsigned char* type,
-                                 unsigned long long* value) {
+static inline void SetTraceValue(
+    const std::string& arg,
+    unsigned char* type,
+    unsigned long long* value,
+    scoped_ptr<base::debug::ConvertableToJSON>* convertable_value) {
   TraceValueUnion type_value;
   type_value.as_string = arg.c_str();
   *type = TRACE_VALUE_TYPE_COPY_STRING;
   *value = type_value.as_uint;
 }
 
+static inline void SetTraceValue(
+    base::debug::ConvertableToJSON* arg,

[dsinclair, 2013/04/09 22:37:45]

This has to be scoped_ptr<base::debug::ConvertableToJSON> arg.

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

Done.

+    unsigned char* type,
+    unsigned long long* value,
+    scoped_ptr<base::debug::ConvertableToJSON>* convertable_value) {
+  *type = TRACE_VALUE_TYPE_CONVERTABLE;
+  convertable_value->reset(arg);
+}
+
 // These AddTraceEvent and AddTraceEventWithThreadIdAndTimestamp template
 // functions are defined here instead of in the macro, because the arg_values
 // could be temporary objects, such as std::string. In order to store
 // 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) {
   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,
       thread_id, now, flags);
 }
 
 template<class ARG1_TYPE>
 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,
     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]);
+  scoped_ptr<base::debug::ConvertableToJSON> convertable_values[1];
+  SetTraceValue(arg1_val, &arg_types[0], &arg_values[0],
+                &convertable_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, convertable_values, 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 13 matching lines @@
     const base::TimeTicks& timestamp,
     unsigned char flags,
     const char* arg1_name,
     const ARG1_TYPE& arg1_val,
     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]);
+  scoped_ptr<base::debug::ConvertableToJSON> convertable_values[2];
+  SetTraceValue(arg1_val, &arg_types[0], &arg_values[0],
+                &convertable_values[0]);
+  SetTraceValue(arg2_val, &arg_types[1], &arg_values[1],
+                &convertable_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, convertable_values, 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 26 matching lines @@
 // This macro generates less code then TRACE_EVENT0 but is also
 // slower to execute when tracing is off. It should generally only be
 // used with code that is seldom executed or conditionally executed
 // when debugging.
 #define TRACE_EVENT_BINARY_EFFICIENT0(category, name) \
     INTERNAL_TRACE_EVENT_BINARY_EFFICIENT_ADD_SCOPED(category, name)
 
 }  // namespace trace_event_internal
 
 #endif  // BASE_DEBUG_TRACE_EVENT_INTERNAL_H_