Update from https://crrev.com/315085

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.
 
 // This header file defines the set of trace_event macros without specifying
 // how the events actually get collected and stored. If you need to expose trace
 // events to some other universe, you can copy-and-paste this file as well as
 // trace_event.h, modifying the macros contained there as necessary for the
 // target platform. The end result is that multiple libraries can funnel events
 // through to a shared trace event collector.
@@ skipping 123 matching lines @@
 //
 //
 // Convertable notes:
 // Converting a large data type to a string can be costly. To help with this,
 // the trace framework provides an interface ConvertableToTraceFormat. If you
 // inherit from it and implement the AppendAsTraceFormat method the trace
 // framework will call back to your object to convert a trace output time. This
 // means, if the category for the event is disabled, the conversion will not
 // happen.
 //
-//   class MyData : public base::debug::ConvertableToTraceFormat {
+//   class MyData : public base::trace_event::ConvertableToTraceFormat {
 //    public:
 //     MyData() {}
 //     virtual void AppendAsTraceFormat(std::string* out) const override {
 //       out->append("{\"foo\":1}");
 //     }
 //    private:
 //     virtual ~MyData() {}
 //     DISALLOW_COPY_AND_ASSIGN(MyData);
 //   };
 //
@@ skipping 434 matching lines @@
 // ASYNC_STEP_PAST events.
 #define TRACE_EVENT_ASYNC_STEP_INTO0(category_group, name, id, step) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_INTO, \
         category_group, name, id, TRACE_EVENT_FLAG_NONE, "step", step)
 #define TRACE_EVENT_ASYNC_STEP_INTO1(category_group, name, id, step, \
                                      arg1_name, arg1_val) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_INTO, \
         category_group, name, id, TRACE_EVENT_FLAG_NONE, "step", step, \
         arg1_name, arg1_val)
 
+// Similar to TRACE_EVENT_ASYNC_STEP_INTOx but with a custom |at| timestamp
+// provided.
+#define TRACE_EVENT_ASYNC_STEP_INTO_WITH_TIMESTAMP0(category_group, name, \
+        id, step, timestamp) \
+    INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP( \
+        TRACE_EVENT_PHASE_ASYNC_STEP_INTO, category_group, name, id, \
+        static_cast<int>(base::PlatformThread::CurrentId()), \
+        timestamp, TRACE_EVENT_FLAG_NONE, "step", step)
+
 // Records a single ASYNC_STEP_PAST event for |step| immediately. If the
 // category is not enabled, then this does nothing. The |name| and |id| must
 // match the ASYNC_BEGIN event above. The |step| param identifies this step
 // within the async event. This should be called at the beginning of the next
 // phase of an asynchronous operation. The ASYNC_BEGIN event must not have any
 // ASYNC_STEP_INTO events.
 #define TRACE_EVENT_ASYNC_STEP_PAST0(category_group, name, id, step) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_PAST, \
         category_group, name, id, TRACE_EVENT_FLAG_NONE, "step", step)
 #define TRACE_EVENT_ASYNC_STEP_PAST1(category_group, name, id, step, \
@@ skipping 179 matching lines @@
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_SNAPSHOT_OBJECT, \
         category_group, name, TRACE_ID_DONT_MANGLE(id), TRACE_EVENT_FLAG_NONE,\
         "snapshot", snapshot)
 
 #define TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group, name, id) \
     INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_DELETE_OBJECT, \
         category_group, name, TRACE_ID_DONT_MANGLE(id), TRACE_EVENT_FLAG_NONE)
 
 #define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() \
     UNLIKELY(*INTERNAL_TRACE_EVENT_UID(category_group_enabled) & \
-        (base::debug::TraceLog::ENABLED_FOR_RECORDING | \
-         base::debug::TraceLog::ENABLED_FOR_EVENT_CALLBACK))
+        (base::trace_event::TraceLog::ENABLED_FOR_RECORDING | \
+         base::trace_event::TraceLog::ENABLED_FOR_EVENT_CALLBACK))
 
 // Macro to efficiently determine if a given category group is enabled.
 #define TRACE_EVENT_CATEGORY_GROUP_ENABLED(category_group, ret) \
     do { \
       INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(category_group); \
       if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
         *ret = true; \
       } else { \
         *ret = false; \
       } \
@@ skipping 22 matching lines @@
 // 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
 // TRACE_EVENT_API_ADD_TRACE_EVENT, because this flag only provides an early out
 // for best performance when tracing is disabled.
 // const unsigned char*
 //     TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(const char* category_group)
 #define TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED \
-    base::debug::TraceLog::GetCategoryGroupEnabled
+    base::trace_event::TraceLog::GetCategoryGroupEnabled
 
 // Get the number of times traces have been recorded. This is used to implement
 // the TRACE_EVENT_IS_NEW_TRACE facility.
 // unsigned int TRACE_EVENT_API_GET_NUM_TRACES_RECORDED()
 #define TRACE_EVENT_API_GET_NUM_TRACES_RECORDED \
-    base::debug::TraceLog::GetInstance()->GetNumTracesRecorded
+    base::trace_event::TraceLog::GetInstance()->GetNumTracesRecorded
 
 // Add a trace event to the platform tracing system.
-// base::debug::TraceEventHandle TRACE_EVENT_API_ADD_TRACE_EVENT(
+// base::trace_event::TraceEventHandle TRACE_EVENT_API_ADD_TRACE_EVENT(
 //                    char phase,
 //                    const unsigned char* category_group_enabled,
 //                    const char* name,
 //                    unsigned long long id,
 //                    int num_args,
 //                    const char** arg_names,
 //                    const unsigned char* arg_types,
 //                    const unsigned long long* arg_values,
 //                    unsigned char flags)
 #define TRACE_EVENT_API_ADD_TRACE_EVENT \
-    base::debug::TraceLog::GetInstance()->AddTraceEvent
+    base::trace_event::TraceLog::GetInstance()->AddTraceEvent
 
 // Add a trace event to the platform tracing system.
-// base::debug::TraceEventHandle TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_TIMESTAMP(
+// base::trace_event::TraceEventHandle
+// TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_TIMESTAMP(
 //                    char phase,
 //                    const unsigned char* category_group_enabled,
 //                    const char* name,
 //                    unsigned long long id,
 //                    int thread_id,
 //                    const TimeTicks& timestamp,
 //                    int num_args,
 //                    const char** arg_names,
 //                    const unsigned char* arg_types,
 //                    const unsigned long long* arg_values,
 //                    unsigned char flags)
 #define TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP \
-    base::debug::TraceLog::GetInstance()->AddTraceEventWithThreadIdAndTimestamp
+    base::trace_event::TraceLog::GetInstance() \
+      ->AddTraceEventWithThreadIdAndTimestamp
 
 // 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::debug::TraceEventHandle id)
+//     base::trace_event::TraceEventHandle id)
 #define TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION \
-    base::debug::TraceLog::GetInstance()->UpdateTraceEventDuration
+    base::trace_event::TraceLog::GetInstance()->UpdateTraceEventDuration
 
 // 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
 #define TRACE_EVENT_API_CLASS_EXPORT BASE_EXPORT
 
@@ skipping 52 matching lines @@
       } \
     } 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); \
     if (INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE()) { \
-      base::debug::TraceEventHandle h = trace_event_internal::AddTraceEvent( \
-          TRACE_EVENT_PHASE_COMPLETE, \
-          INTERNAL_TRACE_EVENT_UID(category_group_enabled), \
-          name, trace_event_internal::kNoEventId, \
-          TRACE_EVENT_FLAG_NONE, ##__VA_ARGS__); \
+      base::trace_event::TraceEventHandle h = \
+          trace_event_internal::AddTraceEvent( \
+              TRACE_EVENT_PHASE_COMPLETE, \
+              INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, \
+              trace_event_internal::kNoEventId, TRACE_EVENT_FLAG_NONE, \
+              ##__VA_ARGS__); \
       INTERNAL_TRACE_EVENT_UID(tracer).Initialize( \
           INTERNAL_TRACE_EVENT_UID(category_group_enabled), name, h); \
     }
 
 // 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); \
@@ skipping 272 matching lines @@
   *type = TRACE_VALUE_TYPE_INT;
   *value = arg.ToInternalValue();
 }
 
 // These AddTraceEvent and AddTraceEventWithThreadIdAndTimestamp template
 // functions are defined here instead of in the macro, because the arg_values
 // could be temporary objects, such as std::string. In order to store
 // pointers to the internal c_str and pass through to the tracing API,
 // the arg_values must live throughout these procedures.
 
-static inline base::debug::TraceEventHandle
+static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TimeTicks& timestamp,
     unsigned char flags,
     const char* arg1_name,
-    const scoped_refptr<base::debug::ConvertableToTraceFormat>& arg1_val) {
+    const scoped_refptr<base::trace_event::ConvertableToTraceFormat>&
+        arg1_val) {
   const int num_args = 1;
   unsigned char arg_types[1] = { TRACE_VALUE_TYPE_CONVERTABLE };
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
       phase, category_group_enabled, name, id, thread_id, timestamp,
       num_args, &arg1_name, arg_types, NULL, &arg1_val, flags);
 }
 
 template<class ARG1_TYPE>
-static inline base::debug::TraceEventHandle
+static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TimeTicks& timestamp,
     unsigned char flags,
     const char* arg1_name,
     const ARG1_TYPE& arg1_val,
     const char* arg2_name,
-    const scoped_refptr<base::debug::ConvertableToTraceFormat>& arg2_val) {
+    const scoped_refptr<base::trace_event::ConvertableToTraceFormat>&
+        arg2_val) {
   const int num_args = 2;
   const char* arg_names[2] = { arg1_name, arg2_name };
 
   unsigned char arg_types[2];
   unsigned long long arg_values[2];
   SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
   arg_types[1] = TRACE_VALUE_TYPE_CONVERTABLE;
 
-  scoped_refptr<base::debug::ConvertableToTraceFormat> convertable_values[2];
+  scoped_refptr<base::trace_event::ConvertableToTraceFormat>
+      convertable_values[2];
   convertable_values[1] = arg2_val;
 
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
       phase, category_group_enabled, name, id, thread_id, timestamp,
       num_args, arg_names, arg_types, arg_values, convertable_values, flags);
 }
 
 template<class ARG2_TYPE>
-static inline base::debug::TraceEventHandle
+static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TimeTicks& timestamp,
     unsigned char flags,
     const char* arg1_name,
-    const scoped_refptr<base::debug::ConvertableToTraceFormat>& arg1_val,
+    const scoped_refptr<base::trace_event::ConvertableToTraceFormat>& arg1_val,
     const char* arg2_name,
     const ARG2_TYPE& arg2_val) {
   const int num_args = 2;
   const char* arg_names[2] = { arg1_name, arg2_name };
 
   unsigned char arg_types[2];
   unsigned long long arg_values[2];
   arg_types[0] = TRACE_VALUE_TYPE_CONVERTABLE;
   arg_values[0] = 0;
   SetTraceValue(arg2_val, &arg_types[1], &arg_values[1]);
 
-  scoped_refptr<base::debug::ConvertableToTraceFormat> convertable_values[2];
+  scoped_refptr<base::trace_event::ConvertableToTraceFormat>
+      convertable_values[2];
   convertable_values[0] = arg1_val;
 
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
       phase, category_group_enabled, name, id, thread_id, timestamp,
       num_args, arg_names, arg_types, arg_values, convertable_values, flags);
 }
 
-static inline base::debug::TraceEventHandle
+static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TimeTicks& timestamp,
     unsigned char flags,
     const char* arg1_name,
-    const scoped_refptr<base::debug::ConvertableToTraceFormat>& arg1_val,
+    const scoped_refptr<base::trace_event::ConvertableToTraceFormat>& arg1_val,
     const char* arg2_name,
-    const scoped_refptr<base::debug::ConvertableToTraceFormat>& arg2_val) {
+    const scoped_refptr<base::trace_event::ConvertableToTraceFormat>&
+        arg2_val) {
   const int num_args = 2;
   const char* arg_names[2] = { arg1_name, arg2_name };
   unsigned char arg_types[2] =
       { TRACE_VALUE_TYPE_CONVERTABLE, TRACE_VALUE_TYPE_CONVERTABLE };
-  scoped_refptr<base::debug::ConvertableToTraceFormat> convertable_values[2] =
-      { arg1_val, arg2_val };
+  scoped_refptr<base::trace_event::ConvertableToTraceFormat>
+      convertable_values[2] = {arg1_val, arg2_val};
 
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
       phase, category_group_enabled, name, id, thread_id, timestamp,
       num_args, arg_names, arg_types, NULL, convertable_values, flags);
 }
 
-static inline base::debug::TraceEventHandle
+static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TimeTicks& timestamp,
     unsigned char flags) {
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
       phase, category_group_enabled, name, id, thread_id, timestamp,
       kZeroNumArgs, NULL, NULL, NULL, NULL, flags);
 }
 
-static inline base::debug::TraceEventHandle AddTraceEvent(
+static inline base::trace_event::TraceEventHandle AddTraceEvent(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     unsigned char flags) {
   int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
   base::TimeTicks now = base::TimeTicks::NowFromSystemTraceTime();
   return AddTraceEventWithThreadIdAndTimestamp(phase, category_group_enabled,
                                                name, id, thread_id, now, flags);
 }
 
 template<class ARG1_TYPE>
-static inline base::debug::TraceEventHandle
+static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TimeTicks& timestamp,
     unsigned char flags,
     const char* arg1_name,
     const ARG1_TYPE& arg1_val) {
   const int num_args = 1;
   unsigned char arg_types[1];
   unsigned long long arg_values[1];
   SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
       phase, category_group_enabled, name, id, thread_id, timestamp,
       num_args, &arg1_name, arg_types, arg_values, NULL, flags);
 }
 
 template<class ARG1_TYPE>
-static inline base::debug::TraceEventHandle AddTraceEvent(
+static inline base::trace_event::TraceEventHandle AddTraceEvent(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     unsigned char flags,
     const char* arg1_name,
     const ARG1_TYPE& arg1_val) {
   int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
   base::TimeTicks now = base::TimeTicks::NowFromSystemTraceTime();
   return AddTraceEventWithThreadIdAndTimestamp(phase, category_group_enabled,
                                                name, id, thread_id, now, flags,
                                                arg1_name, arg1_val);
 }
 
 template<class ARG1_TYPE, class ARG2_TYPE>
-static inline base::debug::TraceEventHandle
+static inline base::trace_event::TraceEventHandle
 AddTraceEventWithThreadIdAndTimestamp(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int thread_id,
     const base::TimeTicks& timestamp,
     unsigned char flags,
     const char* arg1_name,
     const ARG1_TYPE& arg1_val,
     const char* arg2_name,
     const ARG2_TYPE& arg2_val) {
   const int num_args = 2;
   const char* arg_names[2] = { arg1_name, arg2_name };
   unsigned char arg_types[2];
   unsigned long long arg_values[2];
   SetTraceValue(arg1_val, &arg_types[0], &arg_values[0]);
   SetTraceValue(arg2_val, &arg_types[1], &arg_values[1]);
   return TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_THREAD_ID_AND_TIMESTAMP(
       phase, category_group_enabled, name, id, thread_id, timestamp,
       num_args, arg_names, arg_types, arg_values, NULL, flags);
 }
 
 template<class ARG1_TYPE, class ARG2_TYPE>
-static inline base::debug::TraceEventHandle AddTraceEvent(
+static inline base::trace_event::TraceEventHandle AddTraceEvent(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     unsigned char flags,
     const char* arg1_name,
     const ARG1_TYPE& arg1_val,
     const char* arg2_name,
     const ARG2_TYPE& arg2_val) {
   int thread_id = static_cast<int>(base::PlatformThread::CurrentId());
@@ skipping 11 matching lines @@
   ScopedTracer() : p_data_(NULL) {}
 
   ~ScopedTracer() {
     if (p_data_ && *data_.category_group_enabled)
       TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(
           data_.category_group_enabled, data_.name, data_.event_handle);
   }
 
   void Initialize(const unsigned char* category_group_enabled,
                   const char* name,
-                  base::debug::TraceEventHandle event_handle) {
+                  base::trace_event::TraceEventHandle event_handle) {
     data_.category_group_enabled = category_group_enabled;
     data_.name = name;
     data_.event_handle = event_handle;
     p_data_ = &data_;
   }
 
  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::debug::TraceEventHandle event_handle;
+    base::trace_event::TraceEventHandle event_handle;
   };
   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();
 
  private:
   const unsigned char* category_group_enabled_;
   const char* name_;
-  base::debug::TraceEventHandle event_handle_;
+  base::trace_event::TraceEventHandle event_handle_;
 };
 
 // This macro generates less code then TRACE_EVENT0 but is also
 // slower to execute when tracing is off. It should generally only be
 // used with code that is seldom executed or conditionally executed
 // when debugging.
 // For now the category_group must be "gpu".
 #define TRACE_EVENT_BINARY_EFFICIENT0(category_group, name) \
     trace_event_internal::ScopedTraceBinaryEfficient \
         INTERNAL_TRACE_EVENT_UID(scoped_trace)(category_group, name);
@@ skipping 25 matching lines @@
         const_cast<char*>(category_and_name)));
   }
 
  private:
   const char* previous_state_;
 };
 
 }  // namespace trace_event_internal
 
 namespace base {
-namespace debug {
+namespace trace_event {
 
 template<typename IDType> class TraceScopedTrackableObject {
  public:
   TraceScopedTrackableObject(const char* category_group, const char* name,
       IDType id)
     : category_group_(category_group),
       name_(name),
       id_(id) {
     TRACE_EVENT_OBJECT_CREATED_WITH_ID(category_group_, name_, id_);
   }
 
   template <typename ArgType> void snapshot(ArgType snapshot) {
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(category_group_, name_, id_, snapshot);
   }
 
   ~TraceScopedTrackableObject() {
     TRACE_EVENT_OBJECT_DELETED_WITH_ID(category_group_, name_, id_);
   }
 
  private:
   const char* category_group_;
   const char* name_;
   IDType id_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceScopedTrackableObject);
 };
 
-} // namespace debug
-} // namespace base
+}  // namespace trace_event
+}  // namespace base
+
+// TODO(ssid): remove these aliases after the tracing clients are moved to the
+// new trace_event namespace. See crbug.com/451032. ETA: March 2015.
+namespace base {
+namespace debug {
+using base::trace_event::TraceScopedTrackableObject;
+}  // namespace debug
+}  // namespace base
 
 #endif /* BASE_TRACE_EVENT_TRACE_EVENT_H_ */