[tracing] Use trace event profiling for heap profiling

base/trace_event/trace_log.cc

 // Copyright 2015 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.
 
 #include "base/trace_event/trace_log.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 
@@ skipping 1305 matching lines @@
           category_group_enabled, name, scope, id, num_args, arg_names,
           arg_types, arg_values, flags);
     }
   }
 
   // TODO(primiano): Add support for events with copied name crbug.com/581078
   // TODO(ssid): Move push to ScopedTracer after adding profiling support in
   // Blink and skia crbug.com/598426.
   if (!(flags & TRACE_EVENT_FLAG_COPY)) {
     if (AllocationContextTracker::capture_enabled()) {
-      if (phase == TRACE_EVENT_PHASE_BEGIN ||
-          phase == TRACE_EVENT_PHASE_COMPLETE) {
+      if (phase == TRACE_EVENT_PHASE_BEGIN) {
         AllocationContextTracker::GetInstanceForCurrentThread()
             ->PushPseudoStackFrame(name);
       } else if (phase == TRACE_EVENT_PHASE_END) {
-        // The pop for |TRACE_EVENT_PHASE_COMPLETE| events
-        // is in |TraceLog::UpdateTraceEventDuration|.
         AllocationContextTracker::GetInstanceForCurrentThread()
             ->PopPseudoStackFrame(name);
       }
     }
   }
 
   return handle;
 }
 
 void TraceLog::AddMetadataEvent(
@@ skipping 103 matching lines @@
       trace_event->UpdateDuration(now, thread_now);
 #if defined(OS_ANDROID)
       trace_event->SendToATrace();
 #endif
     }
 
     if (trace_options() & kInternalEchoToConsole) {
       console_message =
           EventToConsoleMessage(TRACE_EVENT_PHASE_END, now, trace_event);
     }
-
-    if (base::trace_event::AllocationContextTracker::capture_enabled()) {
-      // The corresponding push is in |AddTraceEventWithThreadIdAndTimestamp|.
-      base::trace_event::AllocationContextTracker::GetInstanceForCurrentThread()
-          ->PopPseudoStackFrame(name);
-    }
   }
 
   if (console_message.size())
     LOG(ERROR) << console_message;
 
   if (category_group_enabled_local & ENABLED_FOR_EVENT_CALLBACK) {
     EventCallback event_callback = reinterpret_cast<EventCallback>(
         subtle::NoBarrier_Load(&event_callback_));
     if (event_callback) {
       event_callback(
@@ skipping 245 matching lines @@
 ScopedTraceBinaryEfficient::ScopedTraceBinaryEfficient(
     const char* category_group,
     const char* name) {
   // The single atom works because for now the category_group can only be "gpu".
   DCHECK_EQ(strcmp(category_group, "gpu"), 0);
   static TRACE_EVENT_API_ATOMIC_WORD atomic = 0;
   INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO_CUSTOM_VARIABLES(
       category_group, atomic, category_group_enabled_);
   name_ = name;
   if (*category_group_enabled_ &
-      base::trace_event::TraceLog::ENABLED_FOR_NON_PROFILING_MODE) {
-    event_handle_ =
-        TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
-            TRACE_EVENT_PHASE_COMPLETE,
-            category_group_enabled_,
-            name,
-            trace_event_internal::kGlobalScope,  // scope
-            trace_event_internal::kNoId,  // id
-            static_cast<int>(base::PlatformThread::CurrentId()),  // thread_id
-            base::TimeTicks::Now(),
-            trace_event_internal::kZeroNumArgs,
-            nullptr,
-            nullptr,
-            nullptr,
-            nullptr,
-            TRACE_EVENT_FLAG_NONE);
+      (base::trace_event::TraceLog::ENABLED_FOR_HEAP_PROFILING |
+       base::trace_event::TraceLog::ENABLED_FOR_NON_PROFILING_MODE)) {
+    if (*category_group_enabled_ &
+        base::trace_event::TraceLog::ENABLED_FOR_HEAP_PROFILING) {
+      base::trace_event::AllocationContextTracker::GetInstanceForCurrentThread()
+          ->PushPseudoStackFrame(name);
+    }
+    if (*category_group_enabled_ &
+        base::trace_event::TraceLog::ENABLED_FOR_NON_PROFILING_MODE) {
+      event_handle_ =
+          TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
+              TRACE_EVENT_PHASE_COMPLETE, category_group_enabled_, name,
+              trace_event_internal::kGlobalScope,                   // scope
+              trace_event_internal::kNoId,                          // id
+              static_cast<int>(base::PlatformThread::CurrentId()),  // thread_id
+              base::TimeTicks::Now(), trace_event_internal::kZeroNumArgs,
+              nullptr, nullptr, nullptr, nullptr, TRACE_EVENT_FLAG_NONE);
+    }
   }
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_ &
-      base::trace_event::TraceLog::ENABLED_FOR_NON_PROFILING_MODE) {
-    TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_, name_,
-                                                event_handle_);
+      (base::trace_event::TraceLog::ENABLED_FOR_HEAP_PROFILING |
+       base::trace_event::TraceLog::ENABLED_FOR_NON_PROFILING_MODE)) {
+    if (*category_group_enabled_ &
+        base::trace_event::TraceLog::ENABLED_FOR_HEAP_PROFILING) {
+      base::trace_event::AllocationContextTracker::GetInstanceForCurrentThread()
+          ->PopPseudoStackFrame(name_);
+    }
+    if (*category_group_enabled_ &
+        base::trace_event::TraceLog::ENABLED_FOR_NON_PROFILING_MODE) {
+      TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_,
+                                                  name_, event_handle_);
+    }
   }
 }
 
 }  // namespace trace_event_internal