Adding raw tracing to 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 is designed to give you trace_event macros without specifying
 // how the events actually get collected and stored. If you need to expose trace
 // event to some other universe, you can copy-and-paste this file,
 // implement the TRACE_EVENT_API macros, and do any other necessary fixup for
 // the target platform. The end result is that multiple libraries can funnel
 // events through to a shared trace event collector.
@@ skipping 247 matching lines @@
         category, name, TRACE_EVENT_FLAG_COPY)
 #define TRACE_EVENT_COPY_BEGIN1(category, name, arg1_name, arg1_val) \
     INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, \
         category, name, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
 #define TRACE_EVENT_COPY_BEGIN2(category, name, arg1_name, arg1_val, \
         arg2_name, arg2_val) \
     INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_BEGIN, \
         category, name, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
         arg2_name, arg2_val)
 
+// Similar to TRACE_EVENT_BEGINx but allowing a custom |thread_name| and
+// a custom |at| timestamp to be provided.
+#define TRACE_RAW_EVENT_BEGIN_AT0(category, thread_name, name, at) \
+    INTERNAL_TRACE_RAW_EVENT_ADD_AT(TRACE_EVENT_PHASE_BEGIN, \
+        category, thread_name, name, at, TRACE_EVENT_FLAG_NONE)
+
 // Records a single END event for "name" immediately. If the category
 // is not enabled, then this does nothing.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
 #define TRACE_EVENT_END0(category, name) \
     INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, \
         category, name, TRACE_EVENT_FLAG_NONE)
 #define TRACE_EVENT_END1(category, name, arg1_name, arg1_val) \
     INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, \
         category, name, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
 #define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, \
         arg2_name, arg2_val) \
     INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, \
         category, name, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val, \
         arg2_name, arg2_val)
 #define TRACE_EVENT_COPY_END0(category, name) \
     INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, \
         category, name, TRACE_EVENT_FLAG_COPY)
 #define TRACE_EVENT_COPY_END1(category, name, arg1_name, arg1_val) \
     INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, \
         category, name, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val)
 #define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, \
         arg2_name, arg2_val) \
     INTERNAL_TRACE_EVENT_ADD(TRACE_EVENT_PHASE_END, \
         category, name, TRACE_EVENT_FLAG_COPY, arg1_name, arg1_val, \
         arg2_name, arg2_val)
 
+// Similar to TRACE_EVENT_ENDx but allowing a custom |thread_name| and
+// a custom |at| timestamp to be provided.
+#define TRACE_RAW_EVENT_END_AT0(category, thread_name, name, at) \
+    INTERNAL_TRACE_RAW_EVENT_ADD_AT(TRACE_EVENT_PHASE_END, \
+        category, thread_name, name, at, TRACE_EVENT_FLAG_NONE)
+
+// Adds trace BEGIN and END events for the provided |start| and |end| times.
+#define TRACE_RAW_EVENT_BETWEEN0(category, thread_name, name, start, end) \

[dsinclair, 2012/11/06 16:25:46]

This was added purely for convenience. At the point where I was using the API I
had both begin and end values. This seemed clearer to me. Can remove if you
think it's just clutter.

+    TRACE_RAW_EVENT_BEGIN_AT0(category, thread_name, name, start); \
+    TRACE_RAW_EVENT_END_AT0(category, thread_name, name, end)
+
 // Time threshold event:
 // Only record the event if the duration is greater than the specified
 // threshold_us (time in microseconds).
 // Records a pair of begin and end events called "name" for the current
 // scope, with 0, 1 or 2 associated arguments. If the category is not
 // enabled, then this does nothing.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
 #define TRACE_EVENT_IF_LONGER_THAN0(threshold_us, category, name) \
     INTERNAL_TRACE_EVENT_ADD_SCOPED_IF_LONGER_THAN(threshold_us, category, name)
@@ skipping 293 matching lines @@
     base::debug::TraceLog::GetInstance()->AddTraceEvent
 
 // Checks if Android ATrace is enabled.
 #if defined(OS_ANDROID)
 #define TRACE_EVENT_API_IS_ATRACE_ENABLED() \
     base::debug::TraceLog::IsATraceEnabled()
 #else
 #define TRACE_EVENT_API_IS_ATRACE_ENABLED() false
 #endif
 
+// Add a trace event to the platform tracing system. Returns thresholdBeginId

[dsinclair, 2012/11/06 16:25:46]

If this isn't part of the API then I'm not going to be able to add the trace
events?

Is it due to the timestamp and thread_name that you'd like this to not appear as
part of the API? Other then those, this is almost the same as the non-raw event
method.

+// for use in a corresponding end TRACE_EVENT_API_ADD_TRACE_RAW_EVENT call.
+// int TRACE_EVENT_API_ADD_TRACE_RAW_EVENT(
+//                    char phase,
+//                    const unsigned char* category_enabled,
+//                    const char* thread_name,
+//                    const char* name,
+//                    int64 timestamp,
+//                    unsigned long long id,
+//                    int num_args,
+//                    const char** arg_names,
+//                    const unsigned char* arg_types,
+//                    const unsigned long long* arg_values,
+//                    int threshold_begin_id,
+//                    long long threshold,
+//                    unsigned char flags)
+#define TRACE_EVENT_API_ADD_TRACE_RAW_EVENT \
+    base::debug::TraceLog::GetInstance()->AddTraceRawEvent
+
 ////////////////////////////////////////////////////////////////////////////////
 
 // Implementation detail: trace event macros create temporary variables
 // to keep instrumentation overhead low. These macros give each temporary
 // variable a unique name based on the line number to prevent name collissions.
 #define INTERNAL_TRACE_EVENT_UID3(a,b) \
     trace_event_unique_##a##b
 #define INTERNAL_TRACE_EVENT_UID2(a,b) \
     INTERNAL_TRACE_EVENT_UID3(a,b)
 #define INTERNAL_TRACE_EVENT_UID(name_prefix) \
@@ skipping 26 matching lines @@
 #define INTERNAL_TRACE_EVENT_ADD(phase, category, name, flags, ...) \
     do { \
       INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
       if (INTERNAL_TRACE_EVENT_IS_ATRACE_OR_CATEGORY_ENABLED()) { \
         trace_event_internal::AddTraceEvent( \
             phase, INTERNAL_TRACE_EVENT_UID(catstatic), name, \
             trace_event_internal::kNoEventId, flags, ##__VA_ARGS__); \
       } \
     } while (0)
 
+// Implementation detail: internal macro to create static category and add
+// event if the category is enabled.
+#define INTERNAL_TRACE_RAW_EVENT_ADD_AT(phase, category, thread_name, name, \
+        at, flags, ...) \
+    do { \
+      INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
+      if (*INTERNAL_TRACE_EVENT_UID(catstatic)) { \
+        trace_event_internal::AddTraceRawEvent( \
+            phase, INTERNAL_TRACE_EVENT_UID(catstatic), thread_name, name, \
+            at, trace_event_internal::kNoEventId, flags, ##__VA_ARGS__); \
+      } \
+    } while (0)
+
 // Implementation detail: internal macro to create static category and add begin
 // event if the category is enabled. Also adds the end event when the scope
 // ends.
 #define INTERNAL_TRACE_EVENT_ADD_SCOPED(category, name, ...) \
     INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
     trace_event_internal::TraceEndOnScopeClose \
         INTERNAL_TRACE_EVENT_UID(profileScope); \
     if (INTERNAL_TRACE_EVENT_IS_ATRACE_OR_CATEGORY_ENABLED()) { \
       trace_event_internal::AddTraceEvent( \
           TRACE_EVENT_PHASE_BEGIN, \
@@ skipping 272 matching lines @@
   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]);
   return TRACE_EVENT_API_ADD_TRACE_EVENT(
       phase, category_enabled, name, id,
       num_args, arg_names, arg_types, arg_values,
       kNoThreshholdBeginId, kNoThresholdValue, flags);
 }
 
+static inline int AddTraceRawEvent(char phase,
+                                   const unsigned char* category_enabled,
+                                   const char* thread_name,
+                                   const char* name,
+                                   int64 timestamp,
+                                   unsigned long long id,
+                                   unsigned char flags) {
+  return TRACE_EVENT_API_ADD_TRACE_RAW_EVENT(
+      phase, category_enabled, thread_name, name, timestamp, id, kZeroNumArgs,
+      NULL, NULL, NULL, kNoThreshholdBeginId, kNoThresholdValue, flags);
+}
+
 // Used by TRACE_EVENTx macro. Do not use directly.
 class BASE_EXPORT TraceEndOnScopeClose {
  public:
   // Note: members of data_ intentionally left uninitialized. See Initialize.
   TraceEndOnScopeClose() : p_data_(NULL) {}
   ~TraceEndOnScopeClose() {
     if (p_data_)
       AddEventIfEnabled();
   }
 
@@ skipping 49 matching lines @@
     const char* name;
     int threshold_begin_id;
   };
   Data* p_data_;
   Data data_;
 };
 
 }  // namespace trace_event_internal
 
 #endif  // BASE_DEBUG_TRACE_EVENT_H_