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 278 matching lines @@
 // 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();
     WTF_MAKE_NONCOPYABLE(TraceID);
 public:
     class WithScope final {
         STACK_ALLOCATED();
+
     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();
+
     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 42 matching lines @@
     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();
+
 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 230 matching lines @@
         m_pdata = &m_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 {
-        DISALLOW_NEW();
+        STACK_ALLOCATED();
         const unsigned char* categoryGroupEnabled;
         const char* name;
         TraceEventHandle eventHandle;
     };
     Data* m_pdata;
     Data m_data;
 };
 
 // TraceEventSamplingStateScope records the current sampling state
 // and sets a new sampling state. When the scope exists, it restores
@@ skipping 47 matching lines @@
     const char* m_categoryGroup;
     const char* m_name;
     IDType m_id;
 };
 
 } // namespace TraceEvent
 
 } // namespace blink
 
 #endif