Support tracing flow events v2 in Blink

third_party/WebKit/Source/platform/TraceEvent.h

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 155 matching lines @@
         blink::TraceEvent::TraceEventHandle h = \
             blink::TraceEvent::addTraceEvent( \
                 TRACE_EVENT_PHASE_COMPLETE, \
                 INTERNALTRACEEVENTUID(categoryGroupEnabled), \
                 name, blink::TraceEvent::noEventId, \
                 TRACE_EVENT_FLAG_NONE, ##__VA_ARGS__); \
         INTERNALTRACEEVENTUID(scopedTracer).initialize( \
             INTERNALTRACEEVENTUID(categoryGroupEnabled), name, h); \
     }
 
+#define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category, name, bindId, flowFlags, ...) \
+    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
+    blink::TraceEvent::ScopedTracer INTERNALTRACEEVENTUID(scopedTracer); \
+    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+        unsigned traceEventFlags = flowFlags; \
+        blink::TraceEvent::TraceID traceEventBindId(bindId, &traceEventFlags); \
+        blink::TraceEvent::TraceEventHandle h = \
+            blink::TraceEvent::addTraceEvent( \
+                TRACE_EVENT_PHASE_COMPLETE, \
+                INTERNALTRACEEVENTUID(categoryGroupEnabled), \
+                name, blink::TraceEvent::noEventId, traceEventBindId.data(), \
+                systemTraceTime(), traceEventFlags, ##__VA_ARGS__); \
+        INTERNALTRACEEVENTUID(scopedTracer).initialize( \
+            INTERNALTRACEEVENTUID(categoryGroupEnabled), name, h); \
+    }
+
 // Implementation detail: internal macro to create static category and add
 // event if the category is enabled.
 #define INTERNAL_TRACE_EVENT_ADD_WITH_ID(phase, category, name, id, flags, ...) \
     do { \
         INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
         if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-            unsigned char traceEventFlags = flags | TRACE_EVENT_FLAG_HAS_ID; \
+            unsigned traceEventFlags = flags | TRACE_EVENT_FLAG_HAS_ID; \
             blink::TraceEvent::TraceID traceEventTraceID( \
                 id, &traceEventFlags); \
             blink::TraceEvent::addTraceEvent( \
                 phase, INTERNALTRACEEVENTUID(categoryGroupEnabled), \
                 name, traceEventTraceID.data(), traceEventFlags, ##__VA_ARGS__); \
         } \
     } while (0)
 
 
 // Implementation detail: internal macro to create static category and add event
 // if the category is enabled.
 #define INTERNAL_TRACE_EVENT_ADD_WITH_ID_AND_TIMESTAMP(phase, category, name, id, timestamp, flags, ...) \
     do { \
         INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
         if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-            unsigned char traceEventFlags = flags | TRACE_EVENT_FLAG_HAS_ID; \
+            unsigned traceEventFlags = flags | TRACE_EVENT_FLAG_HAS_ID; \
             blink::TraceEvent::TraceID traceEventTraceID( \
                 id, &traceEventFlags); \
             blink::TraceEvent::addTraceEvent( \
                 phase, INTERNALTRACEEVENTUID(categoryGroupEnabled), \
-                name, traceEventTraceID.data(), timestamp, traceEventFlags, ##__VA_ARGS__); \
+                name, traceEventTraceID.data(), blink::TraceEvent::noBindId, \
+                timestamp, traceEventFlags, ##__VA_ARGS__); \
         } \
     } while (0)
 
 // Implementation detail: internal macro to create static category and add
 // event if the category is enabled.
 #define INTERNAL_TRACE_EVENT_ADD_WITH_TIMESTAMP(phase, category, name, timestamp, flags, ...) \
     do { \
         INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
         if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
             blink::TraceEvent::addTraceEvent( \
                 phase, INTERNALTRACEEVENTUID(categoryGroupEnabled), name, \
-                blink::TraceEvent::noEventId, timestamp, flags, ##__VA_ARGS__); \
+                blink::TraceEvent::noEventId, blink::TraceEvent::noBindId, \
+                timestamp, flags, ##__VA_ARGS__); \
         } \
     } while (0)
 
 
 // These values must be in sync with base::debug::TraceLog::CategoryGroupEnabledFlags.
 #define ENABLED_FOR_RECORDING (1 << 0)
 #define ENABLED_FOR_EVENT_CALLBACK (1 << 2)
 
 #define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() \
     (*INTERNALTRACEEVENTUID(categoryGroupEnabled) & (ENABLED_FOR_RECORDING | ENABLED_FOR_EVENT_CALLBACK))
 
 #define INTERNAL_TRACE_MEMORY(category, name)
 
 namespace blink {
 
 namespace TraceEvent {
 
 // Specify these values when the corresponding argument of addTraceEvent is not
 // used.
 const int zeroNumArgs = 0;
 const unsigned long long noEventId = 0;
+const unsigned long long noBindId = 0;
 
 // TraceID encapsulates an ID that can either be an integer or pointer. Pointers
 // are mangled with the Process ID so that they are unlikely to collide when the
 // same pointer is used on different processes.
 class TraceID {
 public:
     template<bool dummyMangle> class MangleBehavior {
     public:
         template<typename T> explicit MangleBehavior(T id) : m_data(reinterpret_cast<unsigned long long>(id)) { }
         unsigned long long data() const { return m_data; }
     private:
         unsigned long long m_data;
     };
     typedef MangleBehavior<false> DontMangle;
     typedef MangleBehavior<true> ForceMangle;
 
-    TraceID(const void* id, unsigned char* flags) :
+    TraceID(const void* id, unsigned* flags) :
         m_data(static_cast<unsigned long long>(reinterpret_cast<unsigned long>(id)))
     {
         *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
     }
-    TraceID(ForceMangle id, unsigned char* flags) : m_data(id.data())
+    TraceID(ForceMangle id, unsigned* flags) : m_data(id.data())
     {
         *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
     }
-    TraceID(DontMangle id, unsigned char*) : m_data(id.data()) { }
-    TraceID(unsigned long long id, unsigned char*) : m_data(id) { }
-    TraceID(unsigned long id, unsigned char*) : m_data(id) { }
-    TraceID(unsigned id, unsigned char*) : m_data(id) { }
-    TraceID(unsigned short id, unsigned char*) : m_data(id) { }
-    TraceID(unsigned char id, unsigned char*) : m_data(id) { }
-    TraceID(long long id, unsigned char*) :
+    TraceID(DontMangle id, unsigned*) : m_data(id.data()) { }
+    TraceID(unsigned long long id, unsigned*) : m_data(id) { }
+    TraceID(unsigned long id, unsigned*) : m_data(id) { }
+    TraceID(unsigned id, unsigned*) : m_data(id) { }
+    TraceID(unsigned short id, unsigned*) : m_data(id) { }
+    TraceID(unsigned char id, unsigned*) : m_data(id) { }
+    TraceID(long long id, unsigned*) :
         m_data(static_cast<unsigned long long>(id)) { }
-    TraceID(long id, unsigned char*) :
+    TraceID(long id, unsigned*) :
         m_data(static_cast<unsigned long long>(id)) { }
-    TraceID(int id, unsigned char*) :
+    TraceID(int id, unsigned*) :
         m_data(static_cast<unsigned long long>(id)) { }
-    TraceID(short id, unsigned char*) :
+    TraceID(short id, unsigned*) :
         m_data(static_cast<unsigned long long>(id)) { }
-    TraceID(signed char id, unsigned char*) :
+    TraceID(signed char id, unsigned*) :
         m_data(static_cast<unsigned long long>(id)) { }
 
     unsigned long long data() const { return m_data; }
 
 private:
     unsigned long long m_data;
 };
 
 // Simple union to store various types as unsigned long long.
 union TraceValueUnion {
@@ skipping 98 matching lines @@
 // These addTraceEvent template functions are defined here instead of in the
 // macro, because the arg values could be temporary string objects. 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 TraceEventHandle addTraceEvent(
     char phase,
     const unsigned char* categoryEnabled,
     const char* name,
     unsigned long long id,
+    unsigned long long bindId,
     double timestamp,
-    unsigned char flags)
+    unsigned flags)
 {
     return TRACE_EVENT_API_ADD_TRACE_EVENT(
-        phase, categoryEnabled, name, id, timestamp,
+        phase, categoryEnabled, name, id, bindId, timestamp,
         zeroNumArgs, 0, 0, 0,
         flags);
 }
 
-template<typename ARG1_TYPE>
+template <typename ARG1_TYPE>
 static inline TraceEventHandle addTraceEvent(
     char phase,
     const unsigned char* categoryEnabled,
     const char* name,
     unsigned long long id,
+    unsigned long long bindId,
     double timestamp,
-    unsigned char flags,
+    unsigned flags,
     const char* arg1Name,
     const ARG1_TYPE& arg1Val)
 {
     const int numArgs = 1;
     unsigned char argTypes[1];
     unsigned long long argValues[1];
     setTraceValue(arg1Val, &argTypes[0], &argValues[0]);
     if (isConvertableToTraceFormat(arg1Val)) {
         return TRACE_EVENT_API_ADD_TRACE_EVENT(
-            phase, categoryEnabled, name, id, timestamp,
+            phase, categoryEnabled, name, id, bindId, timestamp,
             numArgs, &arg1Name, argTypes, argValues,
             moveFromIfConvertableToTraceFormat(arg1Val),
             nullptr,
             flags);
     }
     return TRACE_EVENT_API_ADD_TRACE_EVENT(
-        phase, categoryEnabled, name, id, timestamp,
+        phase, categoryEnabled, name, id, bindId, timestamp,
         numArgs, &arg1Name, argTypes, argValues,
         flags);
 }
 
 template<typename ARG1_TYPE, typename ARG2_TYPE>
 static inline TraceEventHandle addTraceEvent(
     char phase,
     const unsigned char* categoryEnabled,
     const char* name,
     unsigned long long id,
+    unsigned long long bindId,
     double timestamp,
-    unsigned char flags,
+    unsigned flags,
     const char* arg1Name,
     const ARG1_TYPE& arg1Val,
     const char* arg2Name,
     const ARG2_TYPE& arg2Val)
 {
     const int numArgs = 2;
     const char* argNames[2] = { arg1Name, arg2Name };
     unsigned char argTypes[2];
     unsigned long long argValues[2];
     setTraceValue(arg1Val, &argTypes[0], &argValues[0]);
     setTraceValue(arg2Val, &argTypes[1], &argValues[1]);
     if (isConvertableToTraceFormat(arg1Val) || isConvertableToTraceFormat(arg2Val)) {
         return TRACE_EVENT_API_ADD_TRACE_EVENT(
-            phase, categoryEnabled, name, id, timestamp,
+            phase, categoryEnabled, name, id, bindId, timestamp,
             numArgs, argNames, argTypes, argValues,
             moveFromIfConvertableToTraceFormat(arg1Val),
             moveFromIfConvertableToTraceFormat(arg2Val),
             flags);
     }
     return TRACE_EVENT_API_ADD_TRACE_EVENT(
-        phase, categoryEnabled, name, id, timestamp,
+        phase, categoryEnabled, name, id, bindId, timestamp,
         numArgs, argNames, argTypes, argValues,
         flags);
 }
 
 static inline TraceEventHandle addTraceEvent(
     char phase,
     const unsigned char* categoryEnabled,
     const char* name,
     unsigned long long id,
-    unsigned char flags)
+    unsigned flags)
 {
-    return addTraceEvent(phase, categoryEnabled, name, id, systemTraceTime(), flags);
+    return addTraceEvent(phase, categoryEnabled, name, id, blink::TraceEvent::noBindId,
+        systemTraceTime(), flags);
 }
 
 template<typename ARG1_TYPE>
 static inline TraceEventHandle addTraceEvent(
     char phase,
     const unsigned char* categoryEnabled,
     const char* name,
     unsigned long long id,
-    unsigned char flags,
+    unsigned flags,
     const char* arg1Name,
     const ARG1_TYPE& arg1Val)
 {
-    return addTraceEvent(phase, categoryEnabled, name, id, systemTraceTime(), flags, arg1Name, arg1Val);
+    return addTraceEvent(phase, categoryEnabled, name, id, blink::TraceEvent::noBindId,
+        systemTraceTime(), flags, arg1Name, arg1Val);
 }
 
 
 template<typename ARG1_TYPE, typename ARG2_TYPE>
 static inline TraceEventHandle addTraceEvent(
     char phase,
     const unsigned char* categoryEnabled,
     const char* name,
     unsigned long long id,
-    unsigned char flags,
+    unsigned flags,
     const char* arg1Name,
     const ARG1_TYPE& arg1Val,
     const char* arg2Name,
     const ARG2_TYPE& arg2Val)
 {
-    return addTraceEvent(phase, categoryEnabled, name, id, systemTraceTime(), flags, arg1Name, arg1Val, arg2Name, arg2Val);
+    return addTraceEvent(phase, categoryEnabled, name, id, blink::TraceEvent::noBindId,
+        systemTraceTime(), flags, arg1Name, arg1Val, arg2Name, arg2Val);
 }
 
 // Used by TRACE_EVENTx macro. Do not use directly.
 class ScopedTracer {
 public:
     // Note: members of m_data intentionally left uninitialized. See initialize.
     ScopedTracer() : m_pdata(0) { }
     ~ScopedTracer()
     {
         if (m_pdata && *m_pdata->categoryGroupEnabled)
@@ skipping 73 matching lines @@
     const char* m_categoryGroup;
     const char* m_name;
     IDType m_id;
 };
 
 } // namespace TraceEvent
 
 } // namespace blink
 
 #endif