Implement frame attribution (FrameBlamer)

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 273 matching lines @@
 const int zeroNumArgs = 0;
 const std::nullptr_t kGlobalScope = nullptr;
 const unsigned long long noEventId = 0;
 const unsigned long long noBindId = 0;
 
 // TraceID encapsulates an ID that can either be an integer or pointer;
 // optionally, it can be paired with a scope string, too. Pointers are mangled
 // with the Process ID so that they are unlikely to collide when the same
 // pointer is used on different processes.
 class TraceID final {
-    STACK_ALLOCATED();
+    DISALLOW_NEW();
     WTF_MAKE_NONCOPYABLE(TraceID);
 public:
     class WithScope final {
-        STACK_ALLOCATED();
+        DISALLOW_NEW();
+
     public:
         template<typename T> WithScope(const char* scope, T id)
             : m_scope(scope), m_data(reinterpret_cast<unsigned long long>(id)) { }
         const char* scope() const { return m_scope; }
         unsigned long long data() const { return m_data; }
     private:
         const char* m_scope = kGlobalScope;
         unsigned long long m_data;
     };
 
     template<bool dummyMangle> class MangleBehavior final {
-        STACK_ALLOCATED();
+        DISALLOW_NEW();
+
     public:
         template<typename T> explicit MangleBehavior(T id) : m_data(reinterpret_cast<unsigned long long>(id)) { }
         explicit MangleBehavior(WithScope scopedID) : m_scope(scopedID.scope()), m_data(scopedID.data()) { }
         const char* scope() const { return m_scope; }
         unsigned long long data() const { return m_data; }
     private:
         const char* m_scope = kGlobalScope;
         unsigned long long m_data;
     };
     typedef MangleBehavior<false> DontMangle;
@@ skipping 41 matching lines @@
     bool m_bool;
     unsigned long long m_uint;
     long long m_int;
     double m_double;
     const void* m_pointer;
     const char* m_string;
 };
 
 // Simple container for const char* that should be copied instead of retained.
 class TraceStringWithCopy {
-    STACK_ALLOCATED();
+    DISALLOW_NEW();
+
 public:
     explicit TraceStringWithCopy(const char* str) : m_str(str) { }
     const char* str() const { return m_str; }
 private:
     const char* m_str;
 };
 
 // Define setTraceValue for each allowed type. It stores the type and
 // value in the return arguments. This allows this API to avoid declaring any
 // structures so that it is portable to third_party libraries.
@@ skipping 204 matching lines @@
     const char* arg2Name,
     const ARG2_TYPE& arg2Val)
 {
     return addTraceEvent(phase, categoryEnabled, name, scope, id,
         blink::TraceEvent::noBindId, EventTracer::systemTraceTime(), flags,
         arg1Name, arg1Val, arg2Name, arg2Val);
 }
 
 // Used by TRACE_EVENTx macro. Do not use directly.
 class ScopedTracer final {
-    STACK_ALLOCATED();
+    DISALLOW_NEW();
     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);
     }
 
@@ skipping 19 matching lines @@
     };
     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 {
-    STACK_ALLOCATED();
+    DISALLOW_NEW();
     WTF_MAKE_NONCOPYABLE(SamplingStateScope);
 public:
     SamplingStateScope(const char* categoryAndName)
     {
         m_previousState = SamplingStateScope<BucketNumber>::current();
         SamplingStateScope<BucketNumber>::set(categoryAndName);
     }
 
     ~SamplingStateScope()
     {
         SamplingStateScope<BucketNumber>::set(m_previousState);
     }
 
     // FIXME: Make load/store to traceSamplingState[] thread-safe and atomic.
     static const char* current()
     {
         return reinterpret_cast<const char*>(*blink::traceSamplingState[BucketNumber]);
     }
     static void set(const char* categoryAndName)
     {
         *blink::traceSamplingState[BucketNumber] = reinterpret_cast<TraceEventAPIAtomicWord>(categoryAndName);
     }
 
 private:
     const char* m_previousState;
 };
 
 template<typename IDType> class TraceScopedTrackableObject {
-    STACK_ALLOCATED();
+    DISALLOW_NEW();
     WTF_MAKE_NONCOPYABLE(TraceScopedTrackableObject);
 public:
     TraceScopedTrackableObject(const char* categoryGroup, const char* name, IDType id)
         : m_categoryGroup(categoryGroup), m_name(name), m_id(id)
     {
         TRACE_EVENT_OBJECT_CREATED_WITH_ID(m_categoryGroup, m_name, m_id);
     }
 
+    template <typename ArgType>
+    void snapshot(ArgType snapshot) const
+    {
+        TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(m_categoryGroup, m_name, m_id, snapshot);
+    }
+
     ~TraceScopedTrackableObject()
     {
         TRACE_EVENT_OBJECT_DELETED_WITH_ID(m_categoryGroup, m_name, m_id);
     }
 
 private:
     const char* m_categoryGroup;
     const char* m_name;
     IDType m_id;
 };
 
 } // namespace TraceEvent
 
 } // namespace blink
 
 #endif