Binds an ID to a Globally Unique ID.

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.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 
 #include "base/atomicops.h"
+#include "base/format_macros.h"
 #include "base/macros.h"
+#include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "base/trace_event/common/trace_event_common.h"
 #include "base/trace_event/heap_profiler.h"
+#include "base/trace_event/trace_event_argument.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 (GLOBAL_)TRACE_ID(_WITH_SCOPE) 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 (GLOBAL_)TRACE_ID(_WITH_SCOPE) macros,

[Primiano Tucci (use gerrit), 2016/08/05 14:20:07]

so the doubt that I have when I see that both these are deprecated is: what is
the default behavior if somebody creates an event with just an id? will it still
be mangled? what will be its visibility?
This is still not clear to me after this CL.

+// 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)
 
+// Sets a flag to indicate that the ID is global across all processes.
+#define GLOBAL_TRACE_ID(...)                  \

[Primiano Tucci (use gerrit), 2016/08/05 14:20:07]

I thought that the ID is already global, reason for which we have
TRACE_ID_MANGLE.
What is the difference between non-global and GLOBAL_TRACE_ID then?

My concern is that we still make sure that whatever new semantic we introduce
has to be not ambiguous with the previous traces. In other words, whatever new
we introduce in the importer, it has to still import correctly the older traces.

+    trace_event_internal::TraceID::WithScope( \
+        trace_event_internal::kGlobalScope, true, __VA_ARGS__)
+
 // 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_WITH_SCOPE(scope, ...) \
+    trace_event_internal::TraceID::WithScope(scope, false, __VA_ARGS__)
+#define GLOBAL_TRACE_ID_WITH_SCOPE(scope, ...) \
+    trace_event_internal::TraceID::WithScope(scope, true, __VA_ARGS__)
 
 // 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::                     \
@@ skipping 287 matching lines @@
                                                          &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.
-#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);         \
-        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__);    \
-        } 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(),                    \
-              "bind_scope", target_id.scope(), ##__VA_ARGS__);                \
-        }                                                                     \
-      }                                                                       \
+// The linked ID will not be mangled.
+#define INTERNAL_TRACE_EVENT_ADD_LINK_IDS(category_group, name, id1, id2)      \
+    do {                                                                       \
+      INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group);                  \
+      if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) {  \
+        unsigned int flags = TRACE_EVENT_FLAG_HAS_ID;                          \
+        trace_event_internal::TraceID id(id1, &flags);                         \
+        unsigned int args_id_flags = TRACE_EVENT_FLAG_NONE;                    \
+        trace_event_internal::TraceID args_id(id2, &args_id_flags);            \
+        std::unique_ptr<TracedValue> value(new TracedValue());                 \

[Primiano Tucci (use gerrit), 2016/08/05 14:20:07]

I don't see any precedent of using TracedValue directly inside here. +oysteine
is definitely a better person to figure out the layering here, but I think there
is a reason (I think related with subprojects) why everything here goes via
trace_event_internal.

+        if (args_id.has_prefix()) {                                            \
+          value->BeginArray("id");                                             \
+          value->AppendString(                                                 \
+              StringPrintf("0x%" PRIx64,                                       \
+                           static_cast<uint64_t>(args_id.prefix())));          \
+          value->AppendString(                                                 \
+              StringPrintf("0x%" PRIx64,                                       \
+                           static_cast<uint64_t>(args_id.raw_id())));          \
+          value->EndArray();                                                   \
+        } else {                                                               \
+          value->SetString(                                                    \
+              "id",                                                            \
+              StringPrintf("0x%" PRIx64,                                       \
+                           static_cast<uint64_t>(args_id.raw_id())));          \
+        }                                                                      \
+        if (args_id_flags & TRACE_EVENT_FLAG_ID_IS_GLOBAL)                     \
+          value->SetBoolean("id_is_global", true);                             \
+        if (args_id.scope() != trace_event_internal::kGlobalScope)             \
+          value->SetString("scope", args_id.scope());                          \
+        trace_event_internal::AddTraceEvent(                                   \
+            TRACE_EVENT_PHASE_BIND_IDS,                                        \
+            INTERNAL_TRACE_EVENT_UID(category_group_enabled),                  \
+            name, id.scope(), id.raw_id(), flags, trace_event_internal::kNoId, \
+            "linked_id", std::move(value));                                    \
+      }                                                                        \
     } while (0)
 
 // Implementation detail: internal macro to create static category and add
-// metadata event if the category is enabled.
+// 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);                 \
     if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
       TRACE_EVENT_API_ADD_METADATA_EVENT(                                   \
           INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,           \
           ##__VA_ARGS__);                                                   \
     }                                                                       \
   } while (0)
 
@@ skipping 10 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:
   class WithScope {
    public:
-    WithScope(const char* scope, unsigned long long raw_id)
-        : scope_(scope), raw_id_(raw_id) {}
+    WithScope(const char* scope, bool is_global, unsigned long long raw_id)
+        : scope_(scope), is_global_(is_global), raw_id_(raw_id) {}
+    WithScope(const char* scope, bool is_global, unsigned long long prefix,

[Primiano Tucci (use gerrit), 2016/08/05 14:20:07]

what is this prefix? I don't see documented this anyways.
While looking to this API as a client the only thing I see is just "yet another
long long argument"

+              unsigned long long raw_id)
+        : scope_(scope), is_global_(is_global), has_prefix_(true),
+          prefix_(prefix), raw_id_(raw_id) {}
+    const char* scope() const { return scope_; }
     unsigned long long raw_id() const { return raw_id_; }
-    const char* scope() const { return scope_; }
+    bool has_prefix() const { return has_prefix_; }
+    unsigned long long prefix() const { return prefix_; }
+    bool is_global() const { return is_global_; }
    private:
     const char* scope_ = nullptr;
+    bool is_global_ = false;
+    bool has_prefix_ = false;
+    unsigned long long prefix_;
     unsigned long long raw_id_;
   };
 
   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_;
   };
 
   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) {}
@@ skipping 13 matching lines @@
   };
   TraceID(const void* raw_id, unsigned int* flags)
       : raw_id_(static_cast<unsigned long long>(
                 reinterpret_cast<uintptr_t>(raw_id))) {
     *flags |= TRACE_EVENT_FLAG_MANGLE_ID;
   }
   TraceID(ForceMangle raw_id, unsigned int* flags) : raw_id_(raw_id.raw_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()) {
+      : raw_id_(maybe_scoped_id.raw_id()) {
+    *flags |= TRACE_EVENT_FLAG_ID_IS_GLOBAL;
   }
   TraceID(unsigned long long raw_id, unsigned int* flags) : raw_id_(raw_id) {
     (void)flags;
   }
   TraceID(unsigned long raw_id, unsigned int* flags) : raw_id_(raw_id) {
     (void)flags;
   }
   TraceID(unsigned int raw_id, unsigned int* flags) : raw_id_(raw_id) {
     (void)flags;
   }
   TraceID(unsigned short raw_id, unsigned int* flags) : raw_id_(raw_id) {
     (void)flags;
   }
   TraceID(unsigned char raw_id, unsigned int* flags) : raw_id_(raw_id) {
     (void)flags;
   }
   TraceID(long long raw_id, unsigned int* flags)
       : raw_id_(static_cast<unsigned long long>(raw_id)) { (void)flags; }
   TraceID(long raw_id, unsigned int* flags)
       : raw_id_(static_cast<unsigned long long>(raw_id)) { (void)flags; }
   TraceID(int raw_id, unsigned int* flags)
       : raw_id_(static_cast<unsigned long long>(raw_id)) { (void)flags; }
   TraceID(short raw_id, unsigned int* flags)
       : raw_id_(static_cast<unsigned long long>(raw_id)) { (void)flags; }
   TraceID(signed char raw_id, unsigned int* flags)
       : raw_id_(static_cast<unsigned long long>(raw_id)) { (void)flags; }
   TraceID(WithScope scoped_id, unsigned int* flags)
-      : scope_(scoped_id.scope()), raw_id_(scoped_id.raw_id()) {}
+      : scope_(scoped_id.scope()), has_prefix_(scoped_id.has_prefix()),
+        prefix_(scoped_id.prefix()), raw_id_(scoped_id.raw_id()) {
+    if (scoped_id.is_global())
+      *flags |= TRACE_EVENT_FLAG_ID_IS_GLOBAL;
+  }
 
   unsigned long long raw_id() const { return raw_id_; }
   const char* scope() const { return scope_; }
+  bool has_prefix() const { return has_prefix_; }
+  unsigned long long prefix() const { return prefix_; }
 
  private:
   const char* scope_ = nullptr;
+  bool has_prefix_ = false;
+  unsigned long long prefix_;
   unsigned long long raw_id_;
 };
 
 // Simple union to store various types as unsigned long long.
 union TraceValueUnion {
   bool as_bool;
   unsigned long long as_uint;
   long long as_int;
   double as_double;
   const void* as_pointer;
@@ skipping 560 matching lines @@
   const char* name_;
   IDType id_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_H_