trace_event_stub.h 7.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230
  1. // Copyright 2020 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #ifndef BASE_TRACE_EVENT_TRACE_EVENT_STUB_H_
  5. #define BASE_TRACE_EVENT_TRACE_EVENT_STUB_H_
  6. #include <stddef.h>
  7. #include <memory>
  8. #include <string>
  9. #include "base/base_export.h"
  10. #include "base/strings/string_piece.h"
  11. #include "base/trace_event/common/trace_event_common.h"
  12. #include "base/trace_event/memory_allocator_dump_guid.h"
  13. #include "base/values.h"
  14. #define TRACE_STR_COPY(str) str
  15. #define TRACE_ID_WITH_SCOPE(scope, ...) 0
  16. #define TRACE_ID_GLOBAL(id) 0
  17. #define TRACE_ID_LOCAL(id) 0
  18. namespace trace_event_internal {
  19. const unsigned long long kNoId = 0;
  20. template <typename... Args>
  21. void Ignore(Args&&... args) {}
  22. struct IgnoredValue {
  23. template <typename... Args>
  24. IgnoredValue(Args&&... args) {}
  25. };
  26. } // namespace trace_event_internal
  27. #define INTERNAL_TRACE_IGNORE(...) \
  28. (false ? trace_event_internal::Ignore(__VA_ARGS__) : (void)0)
  29. #define INTERNAL_TRACE_EVENT_ADD(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__)
  30. #define INTERNAL_TRACE_EVENT_ADD_SCOPED(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__)
  31. #define INTERNAL_TRACE_EVENT_ADD_WITH_ID(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__)
  32. #define INTERNAL_TRACE_LOG_MESSAGE(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__)
  33. #define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(...) \
  34. INTERNAL_TRACE_IGNORE(__VA_ARGS__)
  35. #define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(...) \
  36. INTERNAL_TRACE_IGNORE(__VA_ARGS__)
  37. #define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMPS(...) \
  38. INTERNAL_TRACE_IGNORE(__VA_ARGS__)
  39. // Defined in application_state_proto_android.h
  40. #define TRACE_APPLICATION_STATE(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__)
  41. #define TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION \
  42. trace_event_internal::IgnoredValue
  43. #define TRACE_ID_MANGLE(val) (val)
  44. #define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(cat) INTERNAL_TRACE_IGNORE(cat);
  45. #define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() false
  46. #define TRACE_EVENT_API_CURRENT_THREAD_ID 0
  47. // Typed macros. For these, we have to erase the extra args entirely, as they
  48. // may include a lambda that refers to protozero message types (which aren't
  49. // available in the stub). This may trigger "unused variable" errors at the
  50. // callsite, which have to be addressed at the callsite (e.g. via
  51. // [[maybe_unused]]).
  52. #define TRACE_EVENT_BEGIN(category, name, ...) \
  53. INTERNAL_TRACE_IGNORE(category, name)
  54. #define TRACE_EVENT_END(category, ...) INTERNAL_TRACE_IGNORE(category)
  55. #define TRACE_EVENT(category, name, ...) INTERNAL_TRACE_IGNORE(category, name)
  56. #define TRACE_EVENT_INSTANT(category, name, ...) \
  57. INTERNAL_TRACE_IGNORE(category, name)
  58. #define PERFETTO_INTERNAL_ADD_EMPTY_EVENT() INTERNAL_TRACE_IGNORE()
  59. namespace base {
  60. namespace trace_event {
  61. class BASE_EXPORT ConvertableToTraceFormat {
  62. public:
  63. ConvertableToTraceFormat() = default;
  64. ConvertableToTraceFormat(const ConvertableToTraceFormat&) = delete;
  65. ConvertableToTraceFormat& operator=(const ConvertableToTraceFormat&) = delete;
  66. virtual ~ConvertableToTraceFormat();
  67. // Append the class info to the provided |out| string. The appended
  68. // data must be a valid JSON object. Strings must be properly quoted, and
  69. // escaped. There is no processing applied to the content after it is
  70. // appended.
  71. virtual void AppendAsTraceFormat(std::string* out) const = 0;
  72. };
  73. class BASE_EXPORT TracedValue : public ConvertableToTraceFormat {
  74. public:
  75. explicit TracedValue(size_t capacity = 0) {}
  76. void EndDictionary() {}
  77. void EndArray() {}
  78. void SetInteger(const char* name, int value) {}
  79. void SetDouble(const char* name, double value) {}
  80. void SetBoolean(const char* name, bool value) {}
  81. void SetString(const char* name, base::StringPiece value) {}
  82. void SetValue(const char* name, TracedValue* value) {}
  83. void BeginDictionary(const char* name) {}
  84. void BeginArray(const char* name) {}
  85. void SetIntegerWithCopiedName(base::StringPiece name, int value) {}
  86. void SetDoubleWithCopiedName(base::StringPiece name, double value) {}
  87. void SetBooleanWithCopiedName(base::StringPiece name, bool value) {}
  88. void SetStringWithCopiedName(base::StringPiece name,
  89. base::StringPiece value) {}
  90. void SetValueWithCopiedName(base::StringPiece name, TracedValue* value) {}
  91. void BeginDictionaryWithCopiedName(base::StringPiece name) {}
  92. void BeginArrayWithCopiedName(base::StringPiece name) {}
  93. void AppendInteger(int) {}
  94. void AppendDouble(double) {}
  95. void AppendBoolean(bool) {}
  96. void AppendString(base::StringPiece) {}
  97. void BeginArray() {}
  98. void BeginDictionary() {}
  99. void AppendAsTraceFormat(std::string* out) const override;
  100. };
  101. class BASE_EXPORT TracedValueJSON : public TracedValue {
  102. public:
  103. explicit TracedValueJSON(size_t capacity = 0) : TracedValue(capacity) {}
  104. std::unique_ptr<base::Value> ToBaseValue() const { return nullptr; }
  105. std::string ToJSON() const { return ""; }
  106. std::string ToFormattedJSON() const { return ""; }
  107. };
  108. struct MemoryDumpArgs;
  109. class ProcessMemoryDump;
  110. class BASE_EXPORT MemoryDumpProvider {
  111. public:
  112. MemoryDumpProvider(const MemoryDumpProvider&) = delete;
  113. MemoryDumpProvider& operator=(const MemoryDumpProvider&) = delete;
  114. virtual ~MemoryDumpProvider();
  115. virtual bool OnMemoryDump(const MemoryDumpArgs& args,
  116. ProcessMemoryDump* pmd) = 0;
  117. protected:
  118. MemoryDumpProvider() = default;
  119. };
  120. class BASE_EXPORT MemoryDumpManager {
  121. public:
  122. static constexpr const char* const kTraceCategory =
  123. TRACE_DISABLED_BY_DEFAULT("memory-infra");
  124. };
  125. } // namespace trace_event
  126. } // namespace base
  127. // Stub implementation for
  128. // perfetto::StaticString/ThreadTrack/TracedValue/TracedDictionary/TracedArray.
  129. namespace perfetto {
  130. class TracedArray;
  131. class TracedDictionary;
  132. class EventContext;
  133. class StaticString {
  134. public:
  135. template <typename T>
  136. StaticString(T) {}
  137. };
  138. class DynamicString {
  139. public:
  140. template <typename T>
  141. explicit DynamicString(T) {}
  142. };
  143. class TracedValue {
  144. public:
  145. void WriteInt64(int64_t) && {}
  146. void WriteUInt64(uint64_t) && {}
  147. void WriteDouble(double) && {}
  148. void WriteBoolean(bool) && {}
  149. void WriteString(const char*) && {}
  150. void WriteString(const char*, size_t) && {}
  151. void WriteString(const std::string&) && {}
  152. void WritePointer(const void*) && {}
  153. TracedDictionary WriteDictionary() &&;
  154. TracedArray WriteArray() &&;
  155. };
  156. class TracedDictionary {
  157. public:
  158. TracedValue AddItem(StaticString) { return TracedValue(); }
  159. TracedValue AddItem(DynamicString) { return TracedValue(); }
  160. template <typename T>
  161. void Add(StaticString, T&&) {}
  162. template <typename T>
  163. void Add(DynamicString, T&&) {}
  164. TracedDictionary AddDictionary(StaticString);
  165. TracedDictionary AddDictionary(DynamicString);
  166. TracedArray AddArray(StaticString);
  167. TracedArray AddArray(DynamicString);
  168. };
  169. class TracedArray {
  170. public:
  171. TracedValue AppendItem() { return TracedValue(); }
  172. template <typename T>
  173. void Append(T&&) {}
  174. TracedDictionary AppendDictionary();
  175. TracedArray AppendArray();
  176. };
  177. template <class T>
  178. void WriteIntoTracedValue(TracedValue, T&&) {}
  179. } // namespace perfetto
  180. #endif // BASE_TRACE_EVENT_TRACE_EVENT_STUB_H_