Change sampler code events phase from instant to meta.

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_macros_common.h instead of here.
+// 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/macros.h"
 #include "base/time/time.h"
 #include "base/trace_event/common/trace_event_common.h"
@@ skipping 157 matching lines @@
 
 // Set the duration field of a COMPLETE trace event.
 // void TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
 //     const unsigned char* category_group_enabled,
 //     const char* name,
 //     base::trace_event::TraceEventHandle id)
 #define TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION \
     base::trace_event::TraceLog::GetInstance()->UpdateTraceEventDuration
 
 // Adds a metadata event to the trace log. The |AppendValueAsTraceFormat| method
 // on the convertable value will be called at flush time.

[fmeawad, 2016/02/16 21:47:37]

After a second thought I think it is better to eliminate the version with no
category.

[alph, 2016/02/16 23:19:28]

ok. done

 // TRACE_EVENT_API_ADD_METADATA_EVENT(
-//   const char* event_name,
-//   const char* arg_name,
-//   scoped_refptr<ConvertableToTraceFormat> arg_value)
+//     const char* event_name,
+//     const char* arg_name,
+//     scoped_refptr<ConvertableToTraceFormat> arg_value)
+// TRACE_EVENT_API_ADD_METADATA_EVENT(
+//     const unsigned char* category_group_enabled,
+//     const char* event_name,
+//     const char* arg_name,
+//     scoped_refptr<ConvertableToTraceFormat> arg_value)
 #define TRACE_EVENT_API_ADD_METADATA_EVENT \
     trace_event_internal::AddMetadataEvent
 
 // 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))
 #define TRACE_EVENT_API_ATOMIC_STORE(var, value) \
     base::subtle::NoBarrier_Store(&(var), (value))
 
 // Defines visibility for classes in trace_event.h
@@ skipping 137 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)
 
-// Implementation detail: internal macro to enter and leave a context based on
-// the current scope.
+// 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);                 \
+    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)
+
+// 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) \
   struct INTERNAL_TRACE_EVENT_UID(ScopedContext) {                         \
    public:                                                                 \
     INTERNAL_TRACE_EVENT_UID(ScopedContext)(uint64_t cid) : cid_(cid) {    \
       TRACE_EVENT_ENTER_CONTEXT(category_group, name, cid_);               \
     }                                                                      \
     ~INTERNAL_TRACE_EVENT_UID(ScopedContext)() {                           \
       TRACE_EVENT_LEAVE_CONTEXT(category_group, name, cid_);               \
     }                                                                      \
                                                                            \
@@ skipping 484 matching lines @@
       convertable_values[1] = {arg_value};
   unsigned char arg_types[1] = {TRACE_VALUE_TYPE_CONVERTABLE};
   base::trace_event::TraceLog::GetInstance()->AddMetadataEvent(
       event_name,
       1,  // num_args
       arg_names, arg_types,
       nullptr,  // arg_values
       convertable_values, TRACE_EVENT_FLAG_NONE);
 }
 
+static inline void AddMetadataEvent(
+    const unsigned char* category_group_enabled,
+    const char* event_name,
+    const char* arg_name,
+    scoped_refptr<base::trace_event::ConvertableToTraceFormat> arg_value) {
+  const char* arg_names[1] = {arg_name};
+  scoped_refptr<base::trace_event::ConvertableToTraceFormat>
+      convertable_values[1] = {arg_value};
+  unsigned char arg_types[1] = {TRACE_VALUE_TYPE_CONVERTABLE};
+  base::trace_event::TraceLog::GetInstance()->AddMetadataEvent(
+      category_group_enabled, event_name,
+      1,  // num_args
+      arg_names, arg_types,
+      nullptr,  // arg_values
+      convertable_values, TRACE_EVENT_FLAG_NONE);
+}
+
+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) {
+  const int num_args = 1;
+  const char* arg_names[1] = {arg_name};
+  unsigned char arg_types[1];
+  unsigned long long arg_values[1];
+  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);
+}
+
 template <class ARG1_TYPE>
 static void AddMetadataEvent(const char* event_name,
                              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];
   unsigned long long arg_values[1];
   SetTraceValue(arg_val, &arg_types[0], &arg_values[0]);
 
@@ skipping 118 matching lines @@
   const char* name_;
   IDType id_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_H_