[tracing] Add support for profiling trace events

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/macros.h"
 #include "base/time/time.h"
 #include "base/trace_event/common/trace_event_common.h"
+#include "base/trace_event/heap_profiler_allocation_context_tracker.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
@@ skipping 33 matching lines @@
 //    ...;
 // }
 #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_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_TRACING() \
+  UNLIKELY(*INTERNAL_TRACE_EVENT_UID(category_group_enabled) & \
+           (base::trace_event::TraceLog::ENABLED_FOR_HEAP_PROFILING | \
+            base::trace_event::TraceLog::ENABLED_FOR_NON_PROFILING_MODE))
+
 #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))
+  UNLIKELY(*INTERNAL_TRACE_EVENT_UID(category_group_enabled) & \
+   (base::trace_event::TraceLog::ENABLED_FOR_NON_PROFILING_MODE))
+
+#define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_HEAP_PROFILING() \
+  UNLIKELY(*INTERNAL_TRACE_EVENT_UID(category_group_enabled) & \
+   base::trace_event::TraceLog::ENABLED_FOR_HEAP_PROFILING)
 
 ////////////////////////////////////////////////////////////////////////////////
 // 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 group. 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,
 // TRACE_EVENT_API_ADD_TRACE_EVENT can be called. It's OK if tracing is disabled
 // between the load of the tracing state and the call to
@@ skipping 167 matching lines @@
             phase, INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
             trace_event_internal::kGlobalScope, trace_event_internal::kNoId, \
             flags, trace_event_internal::kNoId, ##__VA_ARGS__); \
       } \
     } while (0)
 
 // Implementation detail: internal macro to create static category and add begin
 // event if the category is enabled. Also adds the end event when the scope
 // ends.
 #define INTERNAL_TRACE_EVENT_ADD_SCOPED(category_group, name, ...) \
-    INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
-    trace_event_internal::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer); \
+  INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
+  trace_event_internal::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer); \
+  if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_TRACING()) { \
     if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
       base::trace_event::TraceEventHandle h = \
           trace_event_internal::AddTraceEvent( \
               TRACE_EVENT_PHASE_COMPLETE, \
               INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
               trace_event_internal::kGlobalScope, trace_event_internal::kNoId, \
               TRACE_EVENT_FLAG_NONE, trace_event_internal::kNoId, \
               ##__VA_ARGS__); \
-      INTERNAL_TRACE_EVENT_UID(tracer).Initialize( \
-          INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, h); \
-    }
+      INTERNAL_TRACE_EVENT_UID(tracer) \
+          .Initialize(INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
+                      h); \
+    } \
+    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_HEAP_PROFILING()) { \
+      INTERNAL_TRACE_EVENT_UID(tracer) \
+          .InitializeForHeapProfiling(name, TRACE_EVENT_FLAG_NONE); \
+    } \
+  }
 
-#define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW( \
-    category_group, name, bind_id, flow_flags, ...) \
+#define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category_group, name, \
+                                                  bind_id, flow_flags, ...) \
   INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
   trace_event_internal::ScopedTracer INTERNAL_TRACE_EVENT_UID(tracer); \
-  if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-    unsigned int trace_event_flags = flow_flags; \
-    trace_event_internal::TraceID trace_event_bind_id(bind_id, \
-                                                      &trace_event_flags); \
-    base::trace_event::TraceEventHandle h = \
-        trace_event_internal::AddTraceEvent( \
-            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); \
+  if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_TRACING()) { \
+    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+      unsigned int trace_event_flags = flow_flags; \
+      trace_event_internal::TraceID trace_event_bind_id(bind_id, \
+                                                        &trace_event_flags); \
+      base::trace_event::TraceEventHandle h = \
+          trace_event_internal::AddTraceEvent( \
+              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); \
+    } \
+    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_HEAP_PROFILING()) { \
+      INTERNAL_TRACE_EVENT_UID(tracer) \
+          .InitializeForHeapProfiling(name, flow_flags); \
+    } \
   }
 
 // 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; \
@@ skipping 651 matching lines @@
       arg_values, nullptr, TRACE_EVENT_FLAG_NONE);
 }
 
 // Used by TRACE_EVENTx macros. Do not use directly.
 class TRACE_EVENT_API_CLASS_EXPORT ScopedTracer {
  public:
   // Note: members of data_ intentionally left uninitialized. See Initialize.
   ScopedTracer() : p_data_(NULL) {}
 
   ~ScopedTracer() {
-    if (p_data_ && *data_.category_group_enabled)
+    if (p_data_ && *data_.category_group_enabled) {
       TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
           data_.category_group_enabled, data_.name, data_.event_handle);
+    }
+    // TODO(ssid): Pop the frame from the pseudo stack if initialized for
+    // profiling is true, after adding profiling mode in skia and Blink
+    // crbug.com/598426.
   }
 
   void Initialize(const unsigned char* category_group_enabled,
                   const char* name,
                   base::trace_event::TraceEventHandle event_handle) {
     data_.category_group_enabled = category_group_enabled;
     data_.name = name;
     data_.event_handle = event_handle;
     p_data_ = &data_;
   }
 
+  void InitializeForHeapProfiling(const char* name, unsigned int flags) {
+    if (!(flags & TRACE_EVENT_FLAG_COPY)) {
+      data_.initialized_for_profiling = true;
+      data_.name = name;
+      // TODO(ssid): Add the frame to the pseudo stack after adding profiling
+      // mode in skia and Blink crbug.com/598426.
+    }
+  }
+
  private:
   // This Data struct workaround is to avoid initializing all the members
   // in Data during construction of this object, since this object is always
   // constructed, even when tracing is disabled. If the members of Data were
   // members of this class instead, compiler warnings occur about potential
   // uninitialized accesses.
   struct Data {
     const unsigned char* category_group_enabled;
     const char* name;
     base::trace_event::TraceEventHandle event_handle;
+    bool initialized_for_profiling;
   };
   Data* p_data_;
   Data data_;
 };
 
 // Used by TRACE_EVENT_BINARY_EFFICIENTx macro. Do not use directly.
 class TRACE_EVENT_API_CLASS_EXPORT ScopedTraceBinaryEfficient {
  public:
   ScopedTraceBinaryEfficient(const char* category_group, const char* name);
   ~ScopedTraceBinaryEfficient();
@@ skipping 72 matching lines @@
   const char* name_;
   IDType id_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_H_