[tracing] Move and rename TRACE_EVENT_API_TASK_EXECUTION_EVENT

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/heap_profiler.h"  // For SCOPED_TASK_EXECUTION_EVENT

[Primiano Tucci (use gerrit), 2016/05/09 17:36:45]

Hmm this should go to base/trace_event/common/trace_event_common.h, not here
right?

[ssid, 2016/05/09 23:49:11]

trace_event_common.h cannot include any file form base since it is included in
other projects like v8. If any other projects want to use the TASK_EXEC api then
they should define SCOPED_TASK_EXECUTION_EVENT.

This is how trace_event currently works. Can you suggest better alternatives? Or
should i ask oysteine@?

[Primiano Tucci (use gerrit), 2016/05/10 16:03:53]

Oh you are right about trace_event_common.h
But this seems to  suggests that the entire TRACE_TASK_EXECUTION should be
defined in trace_event.h and not in common.h, As that macro can't be possibly
used outside of chrome..
And in turn trace_event.h should include heap_profiler.h
Right now you are adding an include which is not needed, but you put there just
because you know that this file is going to be pulled by trace_event_common.h
Let's just put both pieces in trace_event.h at this point.

 #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 172 matching lines @@
 // Defines visibility for classes in trace_event.h
 #define TRACE_EVENT_API_CLASS_EXPORT BASE_EXPORT
 
 // The thread buckets for the sampling profiler.
 TRACE_EVENT_API_CLASS_EXPORT extern \
     TRACE_EVENT_API_ATOMIC_WORD g_trace_state[3];
 
 #define TRACE_EVENT_API_THREAD_BUCKET(thread_bucket)                           \
     g_trace_state[thread_bucket]
 
-// Scoped tracker for task execution context in the heap profiler.
-#define TRACE_EVENT_API_SCOPED_TASK_EXECUTION_EVENT \
-  trace_event_internal::ScopedTaskExecutionEvent
-
 ////////////////////////////////////////////////////////////////////////////////
 
 // Implementation detail: trace event macros create temporary variables
 // to keep instrumentation overhead low. These macros give each temporary
 // variable a unique name based on the line number to prevent name collisions.
 #define INTERNAL_TRACE_EVENT_UID3(a,b) \
     trace_event_unique_##a##b
 #define INTERNAL_TRACE_EVENT_UID2(a,b) \
     INTERNAL_TRACE_EVENT_UID3(a,b)
 #define INTERNAL_TRACE_EVENT_UID(name_prefix) \
@@ skipping 815 matching lines @@
     TRACE_EVENT_API_ATOMIC_STORE(
       g_trace_state[BucketNumber],
       reinterpret_cast<TRACE_EVENT_API_ATOMIC_WORD>(
         const_cast<char*>(category_and_name)));
   }
 
  private:
   const char* previous_state_;
 };
 
-// ScopedTaskExecutionEvent records the current task's context in the heap
-// profiler.
-class ScopedTaskExecutionEvent {
- public:
-  explicit ScopedTaskExecutionEvent(const char* task_context)
-      : context_(task_context) {
-    if (UNLIKELY(
-            base::trace_event::AllocationContextTracker::capture_enabled())) {
-      base::trace_event::AllocationContextTracker::GetInstanceForCurrentThread()
-          ->PushCurrentTaskContext(context_);
-    }
-  }
-
-  ~ScopedTaskExecutionEvent() {
-    if (UNLIKELY(
-            base::trace_event::AllocationContextTracker::capture_enabled())) {
-      base::trace_event::AllocationContextTracker::GetInstanceForCurrentThread()
-          ->PopCurrentTaskContext(context_);
-    }
-  }
-
- private:
-  const char* context_;
-};
-
 }  // namespace trace_event_internal
 
 namespace base {
 namespace trace_event {
 
 template<typename IDType> class TraceScopedTrackableObject {
  public:
   TraceScopedTrackableObject(const char* category_group, const char* name,
       IDType id)
     : category_group_(category_group),
@@ skipping 15 matching lines @@
   const char* name_;
   IDType id_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_H_