Remove pointer mangling API from trace_event.h and use an addTraceEvent flag instead

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 331 matching lines @@
 // Records the value of a counter called "name" immediately. Value
 // must be representable as a 32 bit integer.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
 // - |id| is used to disambiguate counters with the same name. It must either
 //   be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
 //   will be xored with a hash of the process ID so that the same pointer on
 //   two different processes will not collide.
 #define TRACE_COUNTER_ID1(category, name, id, value) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID, \
+        category, name, id, TRACE_EVENT_FLAG_NONE, \
         "value", static_cast<int>(value))
 #define TRACE_COPY_COUNTER_ID1(category, name, id, value) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, \
-        category, name, id, TRACE_EVENT_FLAG_COPY | TRACE_EVENT_FLAG_HAS_ID, \
+        category, name, id, TRACE_EVENT_FLAG_COPY, \
         "value", static_cast<int>(value))
 
 // Records the values of a multi-parted counter called "name" immediately.
 // The UI will treat value1 and value2 as parts of a whole, displaying their
 // values as a stacked-bar chart.
 // - category and name strings must have application lifetime (statics or
 //   literals). They may not include " chars.
 // - |id| is used to disambiguate counters with the same name. It must either
 //   be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
 //   will be xored with a hash of the process ID so that the same pointer on
 //   two different processes will not collide.
 #define TRACE_COUNTER_ID2(category, name, id, value1_name, value1_val, \
         value2_name, value2_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID, \
+        category, name, id, TRACE_EVENT_FLAG_NONE, \
         value1_name, static_cast<int>(value1_val), \
         value2_name, static_cast<int>(value2_val))
 #define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, value1_val, \
         value2_name, value2_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_COUNTER, \
-        category, name, id, TRACE_EVENT_FLAG_COPY | TRACE_EVENT_FLAG_HAS_ID, \
+        category, name, id, TRACE_EVENT_FLAG_COPY, \
         value1_name, static_cast<int>(value1_val), \
         value2_name, static_cast<int>(value2_val))
 
 
 // Records a single START event called "name" immediately, 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.
 // - |id| is used to match the START event with the FINISH event. It must either
 //   be a pointer or an integer value up to 64 bits. If it's a pointer, the bits
 //   will be xored with a hash of the process ID so that the same pointer on
 //   two different processes will not collide.
 #define TRACE_EVENT_START0(category, name, id) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_START, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID)
+        category, name, id, TRACE_EVENT_FLAG_NONE)
 #define TRACE_EVENT_START1(category, name, id, arg1_name, arg1_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_START, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID, arg1_name, arg1_val)
+        category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
 #define TRACE_EVENT_START2(category, name, id, arg1_name, arg1_val, \
         arg2_name, arg2_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_START, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID, \
+        category, name, id, TRACE_EVENT_FLAG_NONE, \
         arg1_name, arg1_val, arg2_name, arg2_val)
 #define TRACE_EVENT_COPY_START0(category, name, id) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_START, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID | TRACE_EVENT_FLAG_COPY)
+        category, name, id, TRACE_EVENT_FLAG_COPY)
 #define TRACE_EVENT_COPY_START1(category, name, id, arg1_name, arg1_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_START, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID | TRACE_EVENT_FLAG_COPY, \
+        category, name, id, TRACE_EVENT_FLAG_COPY, \
         arg1_name, arg1_val)
 #define TRACE_EVENT_COPY_START2(category, name, id, arg1_name, arg1_val, \
         arg2_name, arg2_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_START, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID | TRACE_EVENT_FLAG_COPY, \
+        category, name, id, TRACE_EVENT_FLAG_COPY, \
         arg1_name, arg1_val, arg2_name, arg2_val)
 
 // Records a single FINISH event for "name" immediately. If the category
 // is not enabled, then this does nothing.
 #define TRACE_EVENT_FINISH0(category, name, id) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FINISH, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID)
+        category, name, id, TRACE_EVENT_FLAG_NONE)
 #define TRACE_EVENT_FINISH1(category, name, id, arg1_name, arg1_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FINISH, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID, arg1_name, arg1_val)
+        category, name, id, TRACE_EVENT_FLAG_NONE, arg1_name, arg1_val)
 #define TRACE_EVENT_FINISH2(category, name, id, arg1_name, arg1_val, \
         arg2_name, arg2_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FINISH, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID, \
+        category, name, id, TRACE_EVENT_FLAG_NONE, \
         arg1_name, arg1_val, arg2_name, arg2_val)
 #define TRACE_EVENT_COPY_FINISH0(category, name, id) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FINISH, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID | TRACE_EVENT_FLAG_COPY)
+        category, name, id, TRACE_EVENT_FLAG_COPY)
 #define TRACE_EVENT_COPY_FINISH1(category, name, id, arg1_name, arg1_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FINISH, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID | TRACE_EVENT_FLAG_COPY, \
+        category, name, id, TRACE_EVENT_FLAG_COPY, \
         arg1_name, arg1_val)
 #define TRACE_EVENT_COPY_FINISH2(category, name, id, arg1_name, arg1_val, \
         arg2_name, arg2_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_FINISH, \
-        category, name, id, TRACE_EVENT_FLAG_HAS_ID | TRACE_EVENT_FLAG_COPY, \
+        category, name, id, TRACE_EVENT_FLAG_COPY, \
         arg1_name, arg1_val, arg2_name, arg2_val)
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Implementation specific tracing API definitions.
 
 // Get a pointer to the enabled state of the given trace category. Only
 // long-lived literal strings should be given as the category name. The returned
 // pointer can be held permanently in a local static for example. If the
 // unsigned char is non-zero, tracing is enabled. If tracing is enabled,
@@ skipping 16 matching lines @@
 //                    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_EVENT \
     base::debug::TraceLog::GetInstance()->AddTraceEvent
 
-// Mangle pointer with a hash so that if it occurs on more than one process,
-// it will not collide in the trace data. Pass the returned value to
-// TRACE_EVENT_API_ADD_TRACE_EVENT as the id parameter.
-// unsigned long long TRACE_EVENT_API_GET_ID_FROM_POINTER(void* pointer)
-#define TRACE_EVENT_API_GET_ID_FROM_POINTER \
-    base::debug::TraceLog::GetInstance()->GetInterProcessID
-
 ////////////////////////////////////////////////////////////////////////////////
 
 // 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 55 matching lines @@
           INTERNAL_TRACE_EVENT_UID(catstatic), name, \
           INTERNAL_TRACE_EVENT_UID(begin_event_id), threshold); \
     }
 
 // 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, \
                                          ...) \
     INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
     if (*INTERNAL_TRACE_EVENT_UID(catstatic)) { \
+      unsigned char trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID; \
+      trace_event_internal::TraceID trace_event_trace_id( \
+          id, &trace_event_flags); \
       trace_event_internal::AddTraceEvent( \
           phase, INTERNAL_TRACE_EVENT_UID(catstatic), \
-          name, trace_event_internal::TraceID(id).data(), flags, \
+          name, trace_event_trace_id.data(), trace_event_flags, \
           ##__VA_ARGS__); \
     }
 
 // 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')
 #define TRACE_EVENT_PHASE_END      ('E')
 #define TRACE_EVENT_PHASE_INSTANT  ('I')
 #define TRACE_EVENT_PHASE_START    ('S')
 #define TRACE_EVENT_PHASE_FINISH   ('F')
 #define TRACE_EVENT_PHASE_METADATA ('M')
 #define TRACE_EVENT_PHASE_COUNTER  ('C')
 
 // Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT.
 #define TRACE_EVENT_FLAG_NONE        (static_cast<unsigned char>(0))
-#define TRACE_EVENT_FLAG_COPY        (static_cast<unsigned char>(1<<0))
-#define TRACE_EVENT_FLAG_HAS_ID      (static_cast<unsigned char>(1<<1))
+#define TRACE_EVENT_FLAG_COPY        (static_cast<unsigned char>(1 << 0))
+#define TRACE_EVENT_FLAG_HAS_ID      (static_cast<unsigned char>(1 << 1))
+#define TRACE_EVENT_FLAG_MANGLE_ID   (static_cast<unsigned char>(1 << 2))
 
 // 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))
 
 namespace trace_event_internal {
 
 // Specify these values when the corresponding argument of AddTraceEvent is not
 // used.
 const int kZeroNumArgs = 0;
 const int kNoThreshholdBeginId = -1;
 const long long kNoThresholdValue = 0;
 const unsigned long long kNoEventId = 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:
-  explicit TraceID(void* rhs) :
-      data_(TRACE_EVENT_API_GET_ID_FROM_POINTER(rhs)) {}
-  explicit TraceID(unsigned long long rhs) : data_(rhs) {}
-  explicit TraceID(unsigned long rhs) : data_(rhs) {}
-  explicit TraceID(unsigned int rhs) : data_(rhs) {}
-  explicit TraceID(unsigned short rhs) : data_(rhs) {}
-  explicit TraceID(unsigned char rhs) : data_(rhs) {}
-  explicit TraceID(long long rhs) :
-      data_(static_cast<unsigned long long>(rhs)) {}
-  explicit TraceID(long rhs) : data_(static_cast<unsigned long long>(rhs)) {}
-  explicit TraceID(int rhs) : data_(static_cast<unsigned long long>(rhs)) {}
-  explicit TraceID(short rhs) : data_(static_cast<unsigned long long>(rhs)) {}
-  explicit TraceID(signed char rhs) :
-      data_(static_cast<unsigned long long>(rhs)) {}
+  explicit TraceID(const void* id, unsigned char* flags) :
+      data_(static_cast<unsigned long long>(
+          reinterpret_cast<unsigned long>(id))) {
+    *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
+  }
+  explicit TraceID(unsigned long long id, unsigned char* flags) :
+      data_(id) { (void)flags; }
+  explicit TraceID(unsigned long id, unsigned char* flags) :
+      data_(id) { (void)flags; }
+  explicit TraceID(unsigned int id, unsigned char* flags) :
+      data_(id) { (void)flags; }
+  explicit TraceID(unsigned short id, unsigned char* flags) :
+      data_(id) { (void)flags; }
+  explicit TraceID(unsigned char id, unsigned char* flags) :
+      data_(id) { (void)flags; }
+  explicit TraceID(long long id, unsigned char* flags) :
+      data_(static_cast<unsigned long long>(id)) { (void)flags; }
+  explicit TraceID(long id, unsigned char* flags) :
+      data_(static_cast<unsigned long long>(id)) { (void)flags; }
+  explicit TraceID(int id, unsigned char* flags) :
+      data_(static_cast<unsigned long long>(id)) { (void)flags; }
+  explicit TraceID(short id, unsigned char* flags) :
+      data_(static_cast<unsigned long long>(id)) { (void)flags; }
+  explicit TraceID(signed char id, unsigned char* flags) :
+      data_(static_cast<unsigned long long>(id)) { (void)flags; }
 
   unsigned long long data() const { return data_; }
 
  private:
   unsigned long long data_;
 };
 
 // Simple union to store various types as unsigned long long.
 union TraceValueUnion {
   bool as_bool;
@@ skipping 186 matching lines @@
     const char* name;
     int threshold_begin_id;
   };
   Data* p_data_;
   Data data_;
 };
 
 }  // namespace trace_event_internal
 
 #endif  // BASE_DEBUG_TRACE_EVENT_H_