Source code
Revision control
Copy as Markdown
Other Tools
// Copyright 2020 The Chromium Authors
// 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 <stddef.h>
#include <cstdint>
#include <memory>
#include <string>
#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 <typename... Args>
void Ignore(Args&&... args) {}
struct IgnoredValue {
template <typename... Args>
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_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<base::Value> 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");
};
inline uint64_t GetNextGlobalTraceId() {
return 0;
}
} // namespace trace_event
} // namespace base
// Stub implementation for
// perfetto::StaticString/ThreadTrack/TracedValue/TracedDictionary/TracedArray/
// Track.
namespace perfetto {
class TracedArray;
class TracedDictionary;
class EventContext;
class StaticString {
public:
template <typename T>
StaticString(T) {}
};
class DynamicString {
public:
template <typename T>
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 <typename T>
void Add(StaticString, T&&) {}
template <typename T>
void Add(DynamicString, T&&) {}
TracedDictionary AddDictionary(StaticString);
TracedDictionary AddDictionary(DynamicString);
TracedArray AddArray(StaticString);
TracedArray AddArray(DynamicString);
};
class TracedArray {
public:
TracedValue AppendItem() { return TracedValue(); }
template <typename T>
void Append(T&&) {}
TracedDictionary AppendDictionary();
TracedArray AppendArray();
};
template <class T>
void WriteIntoTracedValue(TracedValue, T&&) {}
struct Track {
explicit Track(uint64_t id) {}
};
namespace protos::pbzero {
namespace SequenceManagerTask {
enum class QueueName {
UNKNOWN_TQ = 0,
DEFAULT_TQ = 1,
TASK_ENVIRONMENT_DEFAULT_TQ = 2,
TEST2_TQ = 3,
TEST_TQ = 4,
};
inline const char* QueueName_Name(QueueName value) {
switch (value) {
case QueueName::UNKNOWN_TQ:
return "UNKNOWN_TQ";
case QueueName::DEFAULT_TQ:
return "DEFAULT_TQ";
case QueueName::TASK_ENVIRONMENT_DEFAULT_TQ:
return "TASK_ENVIRONMENT_DEFAULT_TQ";
case QueueName::TEST2_TQ:
return "TEST2_TQ";
case QueueName::TEST_TQ:
return "TEST_TQ";
}
}
} // namespace SequenceManagerTask
namespace ChromeProcessDescriptor {
enum ProcessType {};
} // namespace ChromeProcessDescriptor
} // namespace protos::pbzero
} // namespace perfetto
#endif // BASE_TRACE_EVENT_TRACE_EVENT_STUB_H_