Tracing: Added necessary plumbing to make sure clocksync metadata events are always included.

base/trace_event/trace_event.h

Index: base/trace_event/trace_event.h
diff --git a/base/trace_event/trace_event.h b/base/trace_event/trace_event.h
index faaccac8eaf34b40ff91b81e633df44246266a6a..320bb1d26e9b7d6066539c94410fcd0cf1a6f1d5 100644
--- a/base/trace_event/trace_event.h
+++ b/base/trace_event/trace_event.h
@@ -195,6 +195,9 @@
 #define TRACE_EVENT_API_ADD_METADATA_EVENT \
     trace_event_internal::AddMetadataEvent
 
+#define TRACE_EVENT_API_ADD_METADATA_EVENT_WITH_TIMESTAMP \
+  trace_event_internal::AddMetadataEventWithTimestamp
+
 // Defines atomic operations used internally by the tracing system.
 #define TRACE_EVENT_API_ATOMIC_WORD base::subtle::AtomicWord
 #define TRACE_EVENT_API_ATOMIC_LOAD(var) base::subtle::NoBarrier_Load(&(var))
@@ -351,16 +354,33 @@ TRACE_EVENT_API_CLASS_EXPORT extern \
 
 // 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, ...)        \
+#define INTERNAL_TRACE_EVENT_METADATA_ADD_IF_ENABLED(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(                                   \
+          TRACE_EVENT_PHASE_METADATA,                                       \
           INTERNAL_TRACE_EVENT_UID(category_group_enabled), name,           \
           ##__VA_ARGS__);                                                   \
     }                                                                       \
   } while (0)
 
+#define INTERNAL_TRACE_EVENT_METADATA_ADD_FORCED(phase, name, ...)             \
+  do {                                                                         \
+    TRACE_EVENT_API_ADD_METADATA_EVENT(                                        \
+        phase, TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("__metadata"), name, \
+        ##__VA_ARGS__);                                                        \
+  } while (0)
+
+#define INTERNAL_TRACE_EVENT_METADATA_ADD_FORCED_WITH_TIMESTAMP(               \
+    phase, name, timestamp, ...)                                               \
+  do {                                                                         \
+    TRACE_EVENT_API_ADD_METADATA_EVENT_WITH_TIMESTAMP(                         \
+        phase, TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("__metadata"), name, \
+        base::TimeTicks::FromInternalValue(timestamp), ##__VA_ARGS__);         \
+  } while (0)
+
 // Implementation detail: internal macro to enter and leave a
 // context based on the current scope.
 #define INTERNAL_TRACE_EVENT_SCOPED_CONTEXT(category_group, name, context) \
@@ -934,28 +954,70 @@ static inline base::trace_event::TraceEventHandle AddTraceEvent(
 }
 
 template <class ARG1_CONVERTABLE_TYPE>
-static inline void AddMetadataEvent(
+static inline void AddMetadataEventWithTimestamp(
+    char phase,
     const unsigned char* category_group_enabled,
     const char* event_name,
+    const base::TimeTicks& timestamp,
     const char* arg_name,
     std::unique_ptr<ARG1_CONVERTABLE_TYPE> arg_value) {
   const char* arg_names[1] = {arg_name};
   unsigned char arg_types[1] = {TRACE_VALUE_TYPE_CONVERTABLE};
   std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
       convertable_values[1] = {std::move(arg_value)};
+
   base::trace_event::TraceLog::GetInstance()->AddMetadataEvent(
-      category_group_enabled, event_name,
+      phase, category_group_enabled, event_name, timestamp,
       1,  // num_args
       arg_names, arg_types,
       nullptr,  // arg_values
       convertable_values, TRACE_EVENT_FLAG_NONE);
 }
 
+template <class ARG1_TYPE, class ARG2_TYPE>
+static inline void AddMetadataEventWithTimestamp(
+    char phase,
+    const unsigned char* category_group_enabled,
+    const char* event_name,
+    const base::TimeTicks& timestamp,
+    const char* arg1_name,
+    const ARG1_TYPE& arg1_val,
+    const char* arg2_name,
+    const ARG2_TYPE& arg2_val) {
+  const int num_args = 2;
+  const char* arg_names[2] = {arg1_name, arg2_name};
+  unsigned char arg_types[2];
+  unsigned long long arg_values[2];
+  SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
+  SetTraceValue(arg2_val, &arg_types[1], &arg_values[1]);
+  base::trace_event::TraceLog::GetInstance()->AddMetadataEvent(
+      phase, category_group_enabled, event_name, timestamp, num_args, arg_names,
+      arg_types, arg_values, nullptr, TRACE_EVENT_FLAG_NONE);
+}
+
+template <class ARG1_TYPE, class ARG2_CONVERTABLE_TYPE>
+static inline void AddMetadataEventWithTimestamp(
+    char phase,
+    const unsigned char* category_group_enabled,
+    const char* event_name,
+    const base::TimeTicks& timestamp,
+    const char* arg1_name,
+    const ARG1_TYPE& arg1_val,
+    const char* arg2_name,
+    std::unique_ptr<ARG2_CONVERTABLE_TYPE> arg2_val) {
+  AddMetadataEventWithTimestamp(phase, category_group_enabled, event_name,
+                                timestamp, arg1_name, arg1_val, arg2_name,
+                                std::move(arg2_val));
+}
+
 template <class ARG1_TYPE>
-static void AddMetadataEvent(const unsigned char* category_group_enabled,
-                             const char* event_name,
-                             const char* arg_name,
-                             const ARG1_TYPE& arg_val) {
+static inline void AddMetadataEventWithTimestamp(
+    char phase,
+    const unsigned char* category_group_enabled,
+    const char* event_name,
+    const base::TimeTicks& timestamp,
+    const char* arg_name,
+    const ARG1_TYPE& arg_val) {
   const int num_args = 1;
   const char* arg_names[1] = {arg_name};
   unsigned char arg_types[1];
@@ -963,8 +1025,31 @@ static void AddMetadataEvent(const unsigned char* category_group_enabled,
   SetTraceValue(arg_val, &arg_types[0], &arg_values[0]);
 
   base::trace_event::TraceLog::GetInstance()->AddMetadataEvent(
-      category_group_enabled, event_name, num_args, arg_names, arg_types,
-      arg_values, nullptr, TRACE_EVENT_FLAG_NONE);
+      phase, category_group_enabled, event_name, timestamp, num_args, arg_names,
+      arg_types, arg_values, nullptr, TRACE_EVENT_FLAG_NONE);
+}
+
+template <class ARG1_CONVERTABLE_TYPE>
+static inline void AddMetadataEvent(
+    char phase,
+    const unsigned char* category_group_enabled,
+    const char* event_name,
+    const char* arg_name,
+    std::unique_ptr<ARG1_CONVERTABLE_TYPE> arg_value) {
+  base::TimeTicks now = base::TimeTicks::Now();
+  AddMetadataEventWithTimestamp(phase, category_group_enabled, event_name, now,
+                                arg_name, std::move(arg_value));
+}
+
+template <class ARG1_TYPE>
+static void AddMetadataEvent(char phase,
+                             const unsigned char* category_group_enabled,
+                             const char* event_name,
+                             const char* arg_name,
+                             const ARG1_TYPE& arg_val) {
+  base::TimeTicks now = base::TimeTicks::Now();
+  AddMetadataEventWithTimestamp(phase, category_group_enabled, event_name, now,
+                                arg_name, arg_val);
 }
 
 // Used by TRACE_EVENTx macros. Do not use directly.