// Copyright 2020 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_STUB_H_ #define BASE_TRACE_EVENT_TRACE_EVENT_STUB_H_ #include #include #include #include "base/base_export.h" #include "base/strings/string_piece.h" #include "base/trace_event/common/trace_event_common.h" #include "base/trace_event/memory_allocator_dump_guid.h" #include "base/values.h" #define TRACE_STR_COPY(str) str #define TRACE_ID_WITH_SCOPE(scope, ...) 0 #define TRACE_ID_GLOBAL(id) 0 #define TRACE_ID_LOCAL(id) 0 namespace trace_event_internal { const unsigned long long kNoId = 0; template void Ignore(Args&&... args) {} struct IgnoredValue { template IgnoredValue(Args&&... args) {} }; } // namespace trace_event_internal #define INTERNAL_TRACE_IGNORE(...) \ (false ? trace_event_internal::Ignore(__VA_ARGS__) : (void)0) #define INTERNAL_TRACE_EVENT_ADD(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__) #define INTERNAL_TRACE_EVENT_ADD_SCOPED(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__) #define INTERNAL_TRACE_EVENT_ADD_WITH_ID(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__) #define INTERNAL_TRACE_LOG_MESSAGE(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__) #define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(...) \ INTERNAL_TRACE_IGNORE(__VA_ARGS__) #define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(...) \ INTERNAL_TRACE_IGNORE(__VA_ARGS__) #define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMPS(...) \ INTERNAL_TRACE_IGNORE(__VA_ARGS__) // Defined in application_state_proto_android.h #define TRACE_APPLICATION_STATE(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__) #define TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION \ trace_event_internal::IgnoredValue #define TRACE_ID_MANGLE(val) (val) #define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(cat) INTERNAL_TRACE_IGNORE(cat); #define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() false #define TRACE_EVENT_API_CURRENT_THREAD_ID 0 // Typed macros. For these, we have to erase the extra args entirely, as they // may include a lambda that refers to protozero message types (which aren't // available in the stub). This may trigger "unused variable" errors at the // callsite, which have to be addressed at the callsite (e.g. via // [[maybe_unused]]). #define TRACE_EVENT_BEGIN(category, name, ...) \ INTERNAL_TRACE_IGNORE(category, name) #define TRACE_EVENT_END(category, ...) INTERNAL_TRACE_IGNORE(category) #define TRACE_EVENT(category, name, ...) INTERNAL_TRACE_IGNORE(category, name) #define TRACE_EVENT_INSTANT(category, name, ...) \ INTERNAL_TRACE_IGNORE(category, name) #define PERFETTO_INTERNAL_ADD_EMPTY_EVENT() INTERNAL_TRACE_IGNORE() namespace base { namespace trace_event { class BASE_EXPORT ConvertableToTraceFormat { public: ConvertableToTraceFormat() = default; ConvertableToTraceFormat(const ConvertableToTraceFormat&) = delete; ConvertableToTraceFormat& operator=(const ConvertableToTraceFormat&) = delete; virtual ~ConvertableToTraceFormat(); // Append the class info to the provided |out| string. The appended // data must be a valid JSON object. Strings must be properly quoted, and // escaped. There is no processing applied to the content after it is // appended. virtual void AppendAsTraceFormat(std::string* out) const = 0; }; class BASE_EXPORT TracedValue : public ConvertableToTraceFormat { public: explicit TracedValue(size_t capacity = 0) {} void EndDictionary() {} void EndArray() {} void SetInteger(const char* name, int value) {} void SetDouble(const char* name, double value) {} void SetBoolean(const char* name, bool value) {} void SetString(const char* name, base::StringPiece value) {} void SetValue(const char* name, TracedValue* value) {} void BeginDictionary(const char* name) {} void BeginArray(const char* name) {} void SetIntegerWithCopiedName(base::StringPiece name, int value) {} void SetDoubleWithCopiedName(base::StringPiece name, double value) {} void SetBooleanWithCopiedName(base::StringPiece name, bool value) {} void SetStringWithCopiedName(base::StringPiece name, base::StringPiece value) {} void SetValueWithCopiedName(base::StringPiece name, TracedValue* value) {} void BeginDictionaryWithCopiedName(base::StringPiece name) {} void BeginArrayWithCopiedName(base::StringPiece name) {} void AppendInteger(int) {} void AppendDouble(double) {} void AppendBoolean(bool) {} void AppendString(base::StringPiece) {} void BeginArray() {} void BeginDictionary() {} void AppendAsTraceFormat(std::string* out) const override; }; class BASE_EXPORT TracedValueJSON : public TracedValue { public: explicit TracedValueJSON(size_t capacity = 0) : TracedValue(capacity) {} std::unique_ptr ToBaseValue() const { return nullptr; } std::string ToJSON() const { return ""; } std::string ToFormattedJSON() const { return ""; } }; struct MemoryDumpArgs; class ProcessMemoryDump; class BASE_EXPORT MemoryDumpProvider { public: MemoryDumpProvider(const MemoryDumpProvider&) = delete; MemoryDumpProvider& operator=(const MemoryDumpProvider&) = delete; virtual ~MemoryDumpProvider(); virtual bool OnMemoryDump(const MemoryDumpArgs& args, ProcessMemoryDump* pmd) = 0; protected: MemoryDumpProvider() = default; }; class BASE_EXPORT MemoryDumpManager { public: static constexpr const char* const kTraceCategory = TRACE_DISABLED_BY_DEFAULT("memory-infra"); }; } // namespace trace_event } // namespace base // Stub implementation for // perfetto::StaticString/ThreadTrack/TracedValue/TracedDictionary/TracedArray. namespace perfetto { class TracedArray; class TracedDictionary; class EventContext; class StaticString { public: template StaticString(T) {} }; class DynamicString { public: template explicit DynamicString(T) {} }; class TracedValue { public: void WriteInt64(int64_t) && {} void WriteUInt64(uint64_t) && {} void WriteDouble(double) && {} void WriteBoolean(bool) && {} void WriteString(const char*) && {} void WriteString(const char*, size_t) && {} void WriteString(const std::string&) && {} void WritePointer(const void*) && {} TracedDictionary WriteDictionary() &&; TracedArray WriteArray() &&; }; class TracedDictionary { public: TracedValue AddItem(StaticString) { return TracedValue(); } TracedValue AddItem(DynamicString) { return TracedValue(); } template void Add(StaticString, T&&) {} template void Add(DynamicString, T&&) {} TracedDictionary AddDictionary(StaticString); TracedDictionary AddDictionary(DynamicString); TracedArray AddArray(StaticString); TracedArray AddArray(DynamicString); }; class TracedArray { public: TracedValue AppendItem() { return TracedValue(); } template void Append(T&&) {} TracedDictionary AppendDictionary(); TracedArray AppendArray(); }; template void WriteIntoTracedValue(TracedValue, T&&) {} } // namespace perfetto #endif // BASE_TRACE_EVENT_TRACE_EVENT_STUB_H_