[tracing] Use trace event profiling for heap profiling

third_party/WebKit/Source/platform/TraceEvent.h

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 152 matching lines @@
                 flags, ##__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, name, ...) \
     INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
     blink::TraceEvent::ScopedTracer INTERNALTRACEEVENTUID(scopedTracer); \
-    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-        blink::TraceEvent::TraceEventHandle h = \
-            blink::TraceEvent::addTraceEvent( \
-                TRACE_EVENT_PHASE_COMPLETE, \
-                INTERNALTRACEEVENTUID(categoryGroupEnabled), name, \
-                blink::TraceEvent::kGlobalScope, blink::TraceEvent::noEventId, \
-                TRACE_EVENT_FLAG_NONE, ##__VA_ARGS__); \
-        INTERNALTRACEEVENTUID(scopedTracer).initialize( \
-            INTERNALTRACEEVENTUID(categoryGroupEnabled), name, h); \
+    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_TRACING()) { \
+        if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+            blink::TraceEvent::TraceEventHandle h = \
+                blink::TraceEvent::addTraceEvent( \
+                    TRACE_EVENT_PHASE_COMPLETE, \
+                    INTERNALTRACEEVENTUID(categoryGroupEnabled), name, \
+                    blink::TraceEvent::kGlobalScope, blink::TraceEvent::noEventId, \
+                    TRACE_EVENT_FLAG_NONE, ##__VA_ARGS__); \
+            INTERNALTRACEEVENTUID(scopedTracer).initialize( \
+                INTERNALTRACEEVENTUID(categoryGroupEnabled), name, h); \
+        } \
+        if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_PROFILING()) { \
+            INTERNALTRACEEVENTUID(scopedTracer) \
+                .initializeForHeapProfiling(name, TRACE_EVENT_FLAG_NONE); \
+        } \
     }
 
 #define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(category, name, bindId, flowFlags, ...) \
     INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
     blink::TraceEvent::ScopedTracer INTERNALTRACEEVENTUID(scopedTracer); \
-    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-        unsigned traceEventFlags = flowFlags; \
-        blink::TraceEvent::TraceID traceEventBindId(bindId, &traceEventFlags); \
-        blink::TraceEvent::TraceEventHandle h = \
-            blink::TraceEvent::addTraceEvent( \
-                TRACE_EVENT_PHASE_COMPLETE, \
-                INTERNALTRACEEVENTUID(categoryGroupEnabled), name, \
-                blink::TraceEvent::kGlobalScope, blink::TraceEvent::noEventId, \
-                traceEventBindId.data(), \
-                EventTracer::systemTraceTime(), traceEventFlags, ##__VA_ARGS__); \
-        INTERNALTRACEEVENTUID(scopedTracer).initialize( \
-            INTERNALTRACEEVENTUID(categoryGroupEnabled), name, h); \
+    if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_TRACING()) { \
+        if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
+            unsigned traceEventFlags = flowFlags; \
+            blink::TraceEvent::TraceID traceEventBindId(bindId, &traceEventFlags); \
+            blink::TraceEvent::TraceEventHandle h = \
+                blink::TraceEvent::addTraceEvent( \
+                    TRACE_EVENT_PHASE_COMPLETE, \
+                    INTERNALTRACEEVENTUID(categoryGroupEnabled), name, \
+                    blink::TraceEvent::kGlobalScope, blink::TraceEvent::noEventId, \
+                    traceEventBindId.data(), \
+                    EventTracer::systemTraceTime(), traceEventFlags, ##__VA_ARGS__); \
+            INTERNALTRACEEVENTUID(scopedTracer).initialize( \
+                INTERNALTRACEEVENTUID(categoryGroupEnabled), name, h); \
+        } \
+        if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_PROFILING()) { \
+            INTERNALTRACEEVENTUID(scopedTracer) \
+                .initializeForHeapProfiling(name, TRACE_EVENT_FLAG_NONE); \
+        } \
     }
 
 // 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, name, id, flags, ...) \
     do { \
         INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category); \
         if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
             unsigned traceEventFlags = flags | TRACE_EVENT_FLAG_HAS_ID; \
             blink::TraceEvent::TraceID traceEventTraceID( \
@@ skipping 53 matching lines @@
         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.data());
 
 // These values must be in sync with base::debug::TraceLog::CategoryGroupEnabledFlags.
 #define ENABLED_FOR_RECORDING (1 << 0)
 #define ENABLED_FOR_EVENT_CALLBACK (1 << 2)
+#define ENABLED_FOR_ETW_EXPORT (1 << 3)
+#define ENABLED_FOR_PROFILING (1 << 4)
+#define ENABLED_FOR_NON_PROFILING_MODE (ENABLED_FOR_RECORDING | ENABLED_FOR_EVENT_CALLBACK | ENABLED_FOR_ETW_EXPORT)
+
+#define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_TRACING() \
+    (*INTERNALTRACEEVENTUID(categoryGroupEnabled) & (ENABLED_FOR_PROFILING | ENABLED_FOR_NON_PROFILING_MODE))
 
 #define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() \
-    (*INTERNALTRACEEVENTUID(categoryGroupEnabled) & (ENABLED_FOR_RECORDING | ENABLED_FOR_EVENT_CALLBACK))
+    (*INTERNALTRACEEVENTUID(categoryGroupEnabled) & ENABLED_FOR_NON_PROFILING_MODE)
+
+#define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_PROFILING() \
+    (*INTERNALTRACEEVENTUID(categoryGroupEnabled) & ENABLED_FOR_PROFILING)
 
 #define INTERNAL_TRACE_MEMORY(category, name)
 
 namespace blink {
 
 namespace TraceEvent {
 
 // Specify these values when the corresponding argument of addTraceEvent is not
 // used.
 const int zeroNumArgs = 0;
@@ skipping 309 matching lines @@
 
 // Used by TRACE_EVENTx macro. Do not use directly.
 class ScopedTracer final {
     STACK_ALLOCATED();
     WTF_MAKE_NONCOPYABLE(ScopedTracer);
 public:
     // Note: members of m_data intentionally left uninitialized. See initialize.
     ScopedTracer() : m_pdata(0) { }
     ~ScopedTracer()
     {
-        if (m_pdata && *m_pdata->categoryGroupEnabled)
-            TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(m_data.categoryGroupEnabled, m_data.name, m_data.eventHandle);
+        if (m_data.name) {
+            if (m_data.initializedForProfiling)
+                blink::EventTracer::pushPseudoStackFrame(m_data.name);
+            if (m_pdata && *m_pdata->categoryGroupEnabled)
+                TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(m_data.categoryGroupEnabled, m_data.name, m_data.eventHandle);
+        }
     }
 
     void initialize(const unsigned char* categoryGroupEnabled, const char* name, TraceEventHandle eventHandle)
     {
         m_data.categoryGroupEnabled = categoryGroupEnabled;
         m_data.name = name;
         m_data.eventHandle = eventHandle;
         m_pdata = &m_data;
     }
 
+    void initializeForHeapProfiling(const char* name, unsigned flags)
+    {
+        if (!(flags & TRACE_EVENT_FLAG_COPY)) {
+            m_data.initializedForProfiling = true;
+            m_data.name = name;
+            blink::EventTracer::pushPseudoStackFrame(name);
+        }
+    }
+
 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 {
         DISALLOW_NEW();
         const unsigned char* categoryGroupEnabled;
         const char* name;
         TraceEventHandle eventHandle;
+        bool initializedForProfiling;
     };
     Data* m_pdata;
     Data m_data;
 };
 
 // TraceEventSamplingStateScope records the current sampling state
 // and sets a new sampling state. When the scope exists, it restores
 // the sampling state having recorded.
 template<size_t BucketNumber>
 class SamplingStateScope final {
@@ skipping 44 matching lines @@
     const char* m_categoryGroup;
     const char* m_name;
     IDType m_id;
 };
 
 } // namespace TraceEvent
 
 } // namespace blink
 
 #endif