Add an explicit way of making IDs local or global

base/trace_event/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.
 
 #ifndef BASE_TRACE_EVENT_TRACE_EVENT_H_
 #define BASE_TRACE_EVENT_TRACE_EVENT_H_
 
 // This header file defines implementation details of how the trace macros in
 // trace_event_common.h collect and store trace events. Anything not
 // implementation-specific should go in trace_event_common.h instead of here.
@@ skipping 10 matching lines @@
 #include "base/trace_event/heap_profiler.h"
 #include "base/trace_event/trace_event_system_stats_monitor.h"
 #include "base/trace_event/trace_log.h"
 #include "build/build_config.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) \
     trace_event_internal::TraceStringWithCopy(str)
 
-// By default, uint64_t ID argument values are not mangled with the Process ID
-// in TRACE_EVENT_ASYNC macros. Use this macro to force Process ID mangling.
+// DEPRECATED: do not use: Consider using TRACE_ID_{GLOBAL, LOCAL} macros,
+// instead. By default, uint64_t ID argument values are not mangled with the
+// Process ID in TRACE_EVENT_ASYNC macros. Use this macro to force Process ID
+// mangling.
 #define TRACE_ID_MANGLE(id) \
     trace_event_internal::TraceID::ForceMangle(id)
 
-// By default, pointers are mangled with the Process ID in TRACE_EVENT_ASYNC
-// macros. Use this macro to prevent Process ID mangling.
+// DEPRECATED: do not use: Consider using TRACE_ID_{GLOBAL, LOCAL} macros,
+// instead. By default, pointers are mangled with the Process ID in
+// TRACE_EVENT_ASYNC macros. Use this macro to prevent Process ID mangling.
 #define TRACE_ID_DONT_MANGLE(id) \
     trace_event_internal::TraceID::DontMangle(id)
 
 // By default, trace IDs are eventually converted to a single 64-bit number. Use
 // this macro to add a scope string.
 #define TRACE_ID_WITH_SCOPE(scope, id) \
     trace_event_internal::TraceID::WithScope(scope, id)
 
+#define TRACE_ID_GLOBAL(id) trace_event_internal::TraceID::GlobalId(id)
+#define TRACE_ID_LOCAL(id) trace_event_internal::TraceID::LocalId(id)
+
 // Sets the current sample state to the given category and name (both must be
 // constant strings). These states are intended for a sampling profiler.
 // Implementation note: we store category and name together because we don't
 // want the inconsistency/expense of storing two pointers.
 // |thread_bucket| is [0..2] and is used to statically isolate samples in one
 // thread from others.
 #define TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET( \
     bucket_number, category, name)                 \
         trace_event_internal::                     \
         TraceEventSamplingStateScope<bucket_number>::Set(category "\0" name)
 
 // Returns a current sampling state of the given bucket.
 #define TRACE_EVENT_GET_SAMPLING_STATE_FOR_BUCKET(bucket_number) \
     trace_event_internal::TraceEventSamplingStateScope<bucket_number>::Current()
 
 // Creates a scope of a sampling state of the given bucket.
 //
 // {  // The sampling state is set within this scope.
 //    TRACE_EVENT_SAMPLING_STATE_SCOPE_FOR_BUCKET(0, "category", "name");
 //    ...;
 // }
 #define TRACE_EVENT_SCOPED_SAMPLING_STATE_FOR_BUCKET(                   \
     bucket_number, category, name)                                      \
     trace_event_internal::TraceEventSamplingStateScope<bucket_number>   \
         traceEventSamplingScope(category "\0" name);
 
 #define TRACE_EVENT_API_CURRENT_THREAD_ID \
   static_cast<int>(base::PlatformThread::CurrentId())
 
+#define INTERNAL_SET_ID_FLAGS(flags, id_bits)               \
+  flags &= TRACE_EVENT_FLAG_ALL - TRACE_EVENT_FLAG_ID_MASK; \
+  flags |= id_bits;
+
 #define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() \
   UNLIKELY(*INTERNAL_TRACE_EVENT_UID(category_group_enabled) &           \
            (base::trace_event::TraceLog::ENABLED_FOR_RECORDING |         \
             base::trace_event::TraceLog::ENABLED_FOR_EVENT_CALLBACK |    \
             base::trace_event::TraceLog::ENABLED_FOR_ETW_EXPORT))
 
 ////////////////////////////////////////////////////////////////////////////////
 // Implementation specific tracing API definitions.
 
 // Get a pointer to the enabled state of the given trace category. Only
@@ skipping 206 matching lines @@
             TRACE_EVENT_PHASE_COMPLETE, \
             INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
             trace_event_internal::kGlobalScope, trace_event_internal::kNoId, \
             trace_event_flags, trace_event_bind_id.raw_id(), ##__VA_ARGS__); \
     INTERNAL_TRACE_EVENT_UID(tracer).Initialize( \
         INTERNAL_TRACE_EVENT_UID(category_group_enabled), 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_group, name, id, \
-                                         flags, ...) \
-    do { \
-      INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
-      if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-        unsigned int 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(category_group_enabled), \
+#define INTERNAL_TRACE_EVENT_ADD_WITH_ID(phase, category_group, name, id,      \
+                                         flags, ...)                           \
+    do {                                                                       \
+      INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                  \
+      if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {  \
+        unsigned int trace_event_flags = flags;                                \
+        trace_event_internal::TraceID trace_event_trace_id(                    \
+            id, &trace_event_flags);                                           \
+        trace_event_internal::AddTraceEvent(                                   \
+            phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled),           \
             name, trace_event_trace_id.scope(), trace_event_trace_id.raw_id(), \
-            trace_event_flags, trace_event_internal::kNoId, ##__VA_ARGS__); \
+            trace_event_flags, trace_event_internal::kNoId, ##__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_group, name, \
                                                 timestamp, flags, ...)       \
   do {                                                                       \
     INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                  \
     if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {  \
       trace_event_internal::AddTraceEventWithThreadIdAndTimestamp(           \
           phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,     \
           trace_event_internal::kGlobalScope, trace_event_internal::kNoId,   \
           TRACE_EVENT_API_CURRENT_THREAD_ID,                                 \
           base::TimeTicks::FromInternalValue(timestamp),                     \
           flags | TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP,                       \
           trace_event_internal::kNoId, ##__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_TID_AND_TIMESTAMP(                   \
     phase, category_group, name, id, thread_id, timestamp, flags, ...)        \
   do {                                                                        \
     INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                   \
     if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {   \
-      unsigned int trace_event_flags = flags | TRACE_EVENT_FLAG_HAS_ID;       \
+      unsigned int trace_event_flags = flags;                                 \
       trace_event_internal::TraceID trace_event_trace_id(id,                  \
                                                          &trace_event_flags); \
       trace_event_internal::AddTraceEventWithThreadIdAndTimestamp(            \
           phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,      \
           trace_event_trace_id.scope(), trace_event_trace_id.raw_id(),        \
           thread_id, base::TimeTicks::FromInternalValue(timestamp),           \
           trace_event_flags | TRACE_EVENT_FLAG_EXPLICIT_TIMESTAMP,            \
           trace_event_internal::kNoId, ##__VA_ARGS__);                        \
     }                                                                         \
   } while (0)
 
-// The trace ID and bind ID will never be mangled by this macro.
+// This macro ignores whether the bind_id is local, global, or mangled.
 #define INTERNAL_TRACE_EVENT_ADD_BIND_IDS(category_group, name, id, bind_id,  \
                                           ...)                                \
     do {                                                                      \
       INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                 \
       if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-        trace_event_internal::TraceID::DontMangle source_id(id);              \
-        trace_event_internal::TraceID::DontMangle target_id(bind_id);         \
+        unsigned int source_flags = TRACE_EVENT_FLAG_NONE;                    \
+        trace_event_internal::TraceID source_id(id, &source_flags);           \
+        unsigned int target_flags = TRACE_EVENT_FLAG_NONE;                    \
+        trace_event_internal::TraceID target_id(bind_id, &target_flags);      \
         if (target_id.scope() == trace_event_internal::kGlobalScope) {        \
           trace_event_internal::AddTraceEvent(                                \
               TRACE_EVENT_PHASE_BIND_IDS,                                     \
               INTERNAL_TRACE_EVENT_UID(category_group_enabled),               \
               name, source_id.scope(), source_id.raw_id(),                    \
-              TRACE_EVENT_FLAG_HAS_ID, target_id.raw_id(), ##__VA_ARGS__);    \
+              source_flags, target_id.raw_id(), ##__VA_ARGS__);               \
         } else {                                                              \
           trace_event_internal::AddTraceEvent(                                \
               TRACE_EVENT_PHASE_BIND_IDS,                                     \
               INTERNAL_TRACE_EVENT_UID(category_group_enabled),               \
               name, source_id.scope(), source_id.raw_id(),                    \
-              TRACE_EVENT_FLAG_HAS_ID, target_id.raw_id(),                    \
+              source_flags, target_id.raw_id(),                               \
               "bind_scope", target_id.scope(), ##__VA_ARGS__);                \
         }                                                                     \
       }                                                                       \
     } while (0)
 
 // Implementation detail: internal macro to create static category and add
 // metadata event if the category is enabled.
 #define INTERNAL_TRACE_EVENT_METADATA_ADD(category_group, name, ...)        \
   do {                                                                      \
     INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                 \
@@ skipping 17 matching lines @@
     }                                                                      \
                                                                            \
    private:                                                                \
     uint64_t cid_;                                                         \
     /* Local class friendly DISALLOW_COPY_AND_ASSIGN */                    \
     INTERNAL_TRACE_EVENT_UID(ScopedContext)                                \
     (const INTERNAL_TRACE_EVENT_UID(ScopedContext)&) {};                   \
     void operator=(const INTERNAL_TRACE_EVENT_UID(ScopedContext)&) {};     \
   };                                                                       \
   INTERNAL_TRACE_EVENT_UID(ScopedContext)                                  \
-  INTERNAL_TRACE_EVENT_UID(scoped_context)(context.raw_id());
+  INTERNAL_TRACE_EVENT_UID(scoped_context)(context);
 
 // Implementation detail: internal macro to trace a task execution with the
 // location where it was posted from.
 #define INTERNAL_TRACE_TASK_EXECUTION(run_function, task)                 \
   TRACE_EVENT2("toplevel", run_function, "src_file",                      \
                (task).posted_from.file_name(), "src_func",                \
                (task).posted_from.function_name());                       \
   TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION INTERNAL_TRACE_EVENT_UID( \
       task_event)((task).posted_from.file_name());
 
 namespace trace_event_internal {
 
 // Specify these values when the corresponding argument of AddTraceEvent is not
 // used.
 const int kZeroNumArgs = 0;
 const std::nullptr_t kGlobalScope = nullptr;
 const unsigned long long kNoId = 0;
 
 // TraceID encapsulates an ID that can either be an integer or pointer. Pointers
 // are by default mangled with the Process ID so that they are unlikely to
 // collide when the same pointer is used on different processes.
 class TraceID {
  public:
+  // Can be combined with WithScope.
+  class LocalId {
+   public:
+    explicit LocalId(unsigned long long raw_id) : raw_id_(raw_id) {}
+    unsigned long long raw_id() const { return raw_id_; }
+   private:
+    unsigned long long raw_id_;
+  };
+
+  // Can be combined with WithScope.
+  class GlobalId {
+   public:
+    explicit GlobalId(unsigned long long raw_id) : raw_id_(raw_id) {}
+    unsigned long long raw_id() const { return raw_id_; }
+   private:
+    unsigned long long raw_id_;
+  };
+
   class WithScope {
    public:
     WithScope(const char* scope, unsigned long long raw_id)
         : scope_(scope), raw_id_(raw_id) {}
+    WithScope(const char* scope, LocalId local_id)
+        : scope_(scope), raw_id_(local_id.raw_id()) {
+      flags_ = TRACE_EVENT_FLAG_HAS_LOCAL_ID;
+    }
+    WithScope(const char* scope, GlobalId global_id)
+        : scope_(scope), raw_id_(global_id.raw_id()) {
+      flags_ = TRACE_EVENT_FLAG_HAS_GLOBAL_ID;
+    }
     unsigned long long raw_id() const { return raw_id_; }
     const char* scope() const { return scope_; }
+    unsigned int flags() const { return flags_; }
    private:
     const char* scope_ = nullptr;
     unsigned long long raw_id_;
+    unsigned int flags_ = TRACE_EVENT_FLAG_HAS_ID;
   };
 
+  // DEPRECATED: consider using LocalId or GlobalId, instead.
   class DontMangle {
    public:
     explicit DontMangle(const void* raw_id)
         : raw_id_(static_cast<unsigned long long>(
               reinterpret_cast<uintptr_t>(raw_id))) {}
     explicit DontMangle(unsigned long long raw_id) : raw_id_(raw_id) {}
     explicit DontMangle(unsigned long raw_id) : raw_id_(raw_id) {}
     explicit DontMangle(unsigned int raw_id) : raw_id_(raw_id) {}
     explicit DontMangle(unsigned short raw_id) : raw_id_(raw_id) {}
     explicit DontMangle(unsigned char raw_id) : raw_id_(raw_id) {}
     explicit DontMangle(long long raw_id)
         : raw_id_(static_cast<unsigned long long>(raw_id)) {}
     explicit DontMangle(long raw_id)
         : raw_id_(static_cast<unsigned long long>(raw_id)) {}
     explicit DontMangle(int raw_id)
         : raw_id_(static_cast<unsigned long long>(raw_id)) {}
     explicit DontMangle(short raw_id)
         : raw_id_(static_cast<unsigned long long>(raw_id)) {}
     explicit DontMangle(signed char raw_id)
         : raw_id_(static_cast<unsigned long long>(raw_id)) {}
-    explicit DontMangle(WithScope scoped_id)
-        : scope_(scoped_id.scope()), raw_id_(scoped_id.raw_id()) {}
-    const char* scope() const { return scope_; }
     unsigned long long raw_id() const { return raw_id_; }
    private:
-    const char* scope_ = nullptr;
     unsigned long long raw_id_;
   };
 
+  // DEPRECATED: consider using LocalId or GlobalId, instead.
   class ForceMangle {
    public:
     explicit ForceMangle(unsigned long long raw_id) : raw_id_(raw_id) {}
     explicit ForceMangle(unsigned long raw_id) : raw_id_(raw_id) {}
     explicit ForceMangle(unsigned int raw_id) : raw_id_(raw_id) {}
     explicit ForceMangle(unsigned short raw_id) : raw_id_(raw_id) {}
     explicit ForceMangle(unsigned char raw_id) : raw_id_(raw_id) {}
     explicit ForceMangle(long long raw_id)
         : raw_id_(static_cast<unsigned long long>(raw_id)) {}
     explicit ForceMangle(long raw_id)
         : raw_id_(static_cast<unsigned long long>(raw_id)) {}
     explicit ForceMangle(int raw_id)
         : raw_id_(static_cast<unsigned long long>(raw_id)) {}
     explicit ForceMangle(short raw_id)
         : raw_id_(static_cast<unsigned long long>(raw_id)) {}
     explicit ForceMangle(signed char raw_id)
         : raw_id_(static_cast<unsigned long long>(raw_id)) {}
     unsigned long long raw_id() const { return raw_id_; }
    private:
     unsigned long long raw_id_;
   };
+
   TraceID(const void* raw_id, unsigned int* flags)
       : raw_id_(static_cast<unsigned long long>(
                 reinterpret_cast<uintptr_t>(raw_id))) {
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
     *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
   }
   TraceID(ForceMangle raw_id, unsigned int* flags) : raw_id_(raw_id.raw_id()) {
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
     *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
   }
-  TraceID(DontMangle maybe_scoped_id, unsigned int* flags)
-      : scope_(maybe_scoped_id.scope()), raw_id_(maybe_scoped_id.raw_id()) {
+  TraceID(DontMangle raw_id, unsigned int* flags) : raw_id_(raw_id.raw_id()) {
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
   }
   TraceID(unsigned long long raw_id, unsigned int* flags) : raw_id_(raw_id) {
-    (void)flags;
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
   }
   TraceID(unsigned long raw_id, unsigned int* flags) : raw_id_(raw_id) {
-    (void)flags;
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
   }
   TraceID(unsigned int raw_id, unsigned int* flags) : raw_id_(raw_id) {
-    (void)flags;
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
   }
   TraceID(unsigned short raw_id, unsigned int* flags) : raw_id_(raw_id) {
-    (void)flags;
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
   }
   TraceID(unsigned char raw_id, unsigned int* flags) : raw_id_(raw_id) {
-    (void)flags;
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
   }
   TraceID(long long raw_id, unsigned int* flags)
-      : raw_id_(static_cast<unsigned long long>(raw_id)) { (void)flags; }
+      : raw_id_(static_cast<unsigned long long>(raw_id)) {
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
+  }
   TraceID(long raw_id, unsigned int* flags)
-      : raw_id_(static_cast<unsigned long long>(raw_id)) { (void)flags; }
+      : raw_id_(static_cast<unsigned long long>(raw_id)) {
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
+  }
   TraceID(int raw_id, unsigned int* flags)
-      : raw_id_(static_cast<unsigned long long>(raw_id)) { (void)flags; }
+      : raw_id_(static_cast<unsigned long long>(raw_id)) {
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
+  }
   TraceID(short raw_id, unsigned int* flags)
-      : raw_id_(static_cast<unsigned long long>(raw_id)) { (void)flags; }
+      : raw_id_(static_cast<unsigned long long>(raw_id)) {
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
+  }
   TraceID(signed char raw_id, unsigned int* flags)
-      : raw_id_(static_cast<unsigned long long>(raw_id)) { (void)flags; }
+      : raw_id_(static_cast<unsigned long long>(raw_id)) {
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_ID);
+  }
+  TraceID(LocalId raw_id, unsigned int* flags) : raw_id_(raw_id.raw_id()) {
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_LOCAL_ID);
+  }
+  TraceID(GlobalId raw_id, unsigned int* flags) : raw_id_(raw_id.raw_id()) {
+    INTERNAL_SET_ID_FLAGS(*flags, TRACE_EVENT_FLAG_HAS_GLOBAL_ID);
+  }
   TraceID(WithScope scoped_id, unsigned int* flags)
-      : scope_(scoped_id.scope()), raw_id_(scoped_id.raw_id()) {}
+      : scope_(scoped_id.scope()), raw_id_(scoped_id.raw_id()) {
+    INTERNAL_SET_ID_FLAGS(*flags, scoped_id.flags());
+  }
 
   unsigned long long raw_id() const { return raw_id_; }
   const char* scope() const { return scope_; }
 
  private:
   const char* scope_ = nullptr;
   unsigned long long raw_id_;
 };
 
 // Simple union to store various types as unsigned long long.
@@ skipping 566 matching lines @@
   const char* name_;
   IDType id_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_H_