Move TraceEvent.h from platform/ to wtf/

Source/wtf/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 145 matching lines @@
 // because addTraceEvent is threadsafe internally and checks the enabled state
 // again under lock.
 //
 // Without the use of these static category pointers and enabled flags all
 // trace points would carry a significant performance cost of aquiring a lock
 // and resolving the category.
 
 #ifndef TraceEvent_h
 #define TraceEvent_h
 
 #include "platform/EventTracer.h"

[haraken, 2014/03/21 17:10:18]

Unfortunately this CL doesn't work because of this include: wtf/TraceEvent.h
needs to include platform/EventTracer.h...

- TraceEvent somehow needs to interact with platform APIs, which means that
TraceEvent depends on platform/, which means that TraceEvent cannot be put into
wtf/.

- We want to use TraceEvent in heap/, which means that TraceEvent should be put
into wtf/.

Do you have any idea to address this issue? One possible approach would be to
keep TraceEvent in platform/ and pass a function pointer to heap/ so that heap/
can use TraceEvent. But it's ugly.

-
 #include "wtf/DynamicAnnotations.h"
 #include "wtf/text/CString.h"
 
 // By default, const char* argument values are assumed to have long-lived scope
 // and will not be copied. Use this macro to force a const char* to be copied.
 #define TRACE_STR_COPY(str) \
     WebCore::TraceEvent::TraceStringWithCopy(str)
 
 // By default, uint64 ID argument values are not mangled with the Process ID in
 // TRACE_EVENT_ASYNC macros. Use this macro to force Process ID mangling.
@@ skipping 384 matching lines @@
     INTERNAL_TRACE_EVENT_UID3(a, b)
 #define INTERNALTRACEEVENTUID(name_prefix) \
     INTERNAL_TRACE_EVENT_UID2(name_prefix, __LINE__)
 
 // Implementation detail: internal macro to create static category.
 // - WTF_ANNOTATE_BENIGN_RACE, see Thread Safety above.
 
 #define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category) \
     static const unsigned char* INTERNALTRACEEVENTUID(categoryGroupEnabled) = 0; \
     WTF_ANNOTATE_BENIGN_RACE(&INTERNALTRACEEVENTUID(categoryGroupEnabled), \
-                             "trace_event category"); \
+        "trace_event category"); \
     if (!INTERNALTRACEEVENTUID(categoryGroupEnabled)) { \
         INTERNALTRACEEVENTUID(categoryGroupEnabled) = \
             TRACE_EVENT_API_GET_CATEGORY_ENABLED(category); \
     }
 
 // Implementation detail: internal macro to create static category and add
 // event if the category is enabled.
 #define INTERNAL_TRACE_EVENT_ADD(phase, category, name, flags, ...) \
     do { \
         INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
@@ skipping 16 matching lines @@
                 TRACE_EVENT_PHASE_COMPLETE, \
                 INTERNALTRACEEVENTUID(categoryGroupEnabled), \
                 name, WebCore::TraceEvent::noEventId, \
                 TRACE_EVENT_FLAG_NONE, ##__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, \
-                                         ...) \
+#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; \
             WebCore::TraceEvent::TraceID traceEventTraceID( \
                 id, &traceEventFlags); \
             WebCore::TraceEvent::addTraceEvent( \
                 phase, INTERNALTRACEEVENTUID(categoryGroupEnabled), \
-                name, traceEventTraceID.data(), traceEventFlags, \
-                ##__VA_ARGS__); \
+                name, traceEventTraceID.data(), traceEventFlags, ##__VA_ARGS__); \
         } \
     } while (0)
 
 // Notes regarding the following definitions:
 // New values can be added and propagated to third party libraries, but existing
 // definitions must never be changed, because third party libraries may use old
 // definitions.
 
 // Phase indicates the nature of an event entry. E.g. part of a begin/end pair.
 #define TRACE_EVENT_PHASE_BEGIN    ('B')
@@ skipping 105 matching lines @@
 public:
     explicit TraceStringWithCopy(const char* str) : m_str(str) { }
     operator const char* () const { return m_str; }
 private:
     const char* m_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) { \
+#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) { \
         TraceValueUnion typeValue; \
         typeValue.union_member = arg; \
         *type = value_type_id; \
         *value = typeValue.m_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) { \
+#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) { \
         *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 int, TRACE_VALUE_TYPE_UINT)
+INTERNAL_DECLARE_SET_TRACE_VALUE_INT(unsigned, 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(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, m_bool, TRACE_VALUE_TYPE_BOOL)
 INTERNAL_DECLARE_SET_TRACE_VALUE(double, m_double, TRACE_VALUE_TYPE_DOUBLE)
-INTERNAL_DECLARE_SET_TRACE_VALUE(const void*, m_pointer,
-                                 TRACE_VALUE_TYPE_POINTER)
-INTERNAL_DECLARE_SET_TRACE_VALUE(const char*, m_string,
-                                 TRACE_VALUE_TYPE_STRING)
-INTERNAL_DECLARE_SET_TRACE_VALUE(const TraceStringWithCopy&, m_string,
-                                 TRACE_VALUE_TYPE_COPY_STRING)
+INTERNAL_DECLARE_SET_TRACE_VALUE(const void*, m_pointer, TRACE_VALUE_TYPE_POINTER)
+INTERNAL_DECLARE_SET_TRACE_VALUE(const char*, m_string, TRACE_VALUE_TYPE_STRING)
+INTERNAL_DECLARE_SET_TRACE_VALUE(const TraceStringWithCopy&, m_string, TRACE_VALUE_TYPE_COPY_STRING)
 
 #undef INTERNAL_DECLARE_SET_TRACE_VALUE
 #undef INTERNAL_DECLARE_SET_TRACE_VALUE_INT
 
 // WTF::String version of setTraceValue so that trace arguments can be strings.
 static inline void setTraceValue(const WTF::CString& arg, unsigned char* type, unsigned long long* value)
 {
     TraceValueUnion typeValue;
     typeValue.m_string = arg.data();
     *type = TRACE_VALUE_TYPE_COPY_STRING;
@@ skipping 146 matching lines @@
     const char* m_categoryGroup;
     const char* m_name;
     IDType m_id;
 };
 
 } // namespace TraceEvent
 
 } // namespace WebCore
 
 #endif