tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

trace_event_stub.h (8102B)

      1 // Copyright 2020 The Chromium Authors
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef BASE_TRACE_EVENT_TRACE_EVENT_STUB_H_
      6 #define BASE_TRACE_EVENT_TRACE_EVENT_STUB_H_
      7 
      8 #include <stddef.h>
      9 
     10 #include <cstdint>
     11 #include <memory>
     12 #include <string>
     13 
     14 #include "base/base_export.h"
     15 #include "base/strings/string_piece.h"
     16 #include "base/trace_event/common/trace_event_common.h"
     17 #include "base/trace_event/memory_allocator_dump_guid.h"
     18 #if !defined(MOZ_SANDBOX)
     19 #include "base/values.h"
     20 #endif
     21 
     22 #define TRACE_STR_COPY(str) str
     23 #define TRACE_ID_WITH_SCOPE(scope, ...) 0
     24 #define TRACE_ID_GLOBAL(id) 0
     25 #define TRACE_ID_LOCAL(id) 0
     26 
     27 namespace trace_event_internal {
     28 
     29 const unsigned long long kNoId = 0;
     30 
     31 template <typename... Args>
     32 void Ignore(Args&&... args) {}
     33 
     34 struct IgnoredValue {
     35  template <typename... Args>
     36  IgnoredValue(Args&&... args) {}
     37 };
     38 
     39 }  // namespace trace_event_internal
     40 
     41 #define INTERNAL_TRACE_IGNORE(...) \
     42  (false ? trace_event_internal::Ignore(__VA_ARGS__) : (void)0)
     43 
     44 #define INTERNAL_TRACE_EVENT_ADD(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__)
     45 #define INTERNAL_TRACE_EVENT_ADD_SCOPED(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__)
     46 #define INTERNAL_TRACE_EVENT_ADD_WITH_ID(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__)
     47 #define INTERNAL_TRACE_EVENT_ADD_SCOPED_WITH_FLOW(...) \
     48  INTERNAL_TRACE_IGNORE(__VA_ARGS__)
     49 #define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMP(...) \
     50  INTERNAL_TRACE_IGNORE(__VA_ARGS__)
     51 #define INTERNAL_TRACE_EVENT_ADD_WITH_ID_TID_AND_TIMESTAMPS(...) \
     52  INTERNAL_TRACE_IGNORE(__VA_ARGS__)
     53 
     54 // Defined in application_state_proto_android.h
     55 #define TRACE_APPLICATION_STATE(...) INTERNAL_TRACE_IGNORE(__VA_ARGS__)
     56 
     57 #define TRACE_HEAP_PROFILER_API_SCOPED_TASK_EXECUTION \
     58  trace_event_internal::IgnoredValue
     59 
     60 #define TRACE_ID_MANGLE(val) (val)
     61 
     62 #define INTERNAL_TRACE_EVENT_GET_CATEGORY_INFO(cat) INTERNAL_TRACE_IGNORE(cat);
     63 #define INTERNAL_TRACE_EVENT_CATEGORY_GROUP_ENABLED_FOR_RECORDING_MODE() false
     64 
     65 #define TRACE_EVENT_API_CURRENT_THREAD_ID 0
     66 
     67 // Typed macros. For these, we have to erase the extra args entirely, as they
     68 // may include a lambda that refers to protozero message types (which aren't
     69 // available in the stub). This may trigger "unused variable" errors at the
     70 // callsite, which have to be addressed at the callsite (e.g. via
     71 // [[maybe_unused]]).
     72 #define TRACE_EVENT_BEGIN(category, name, ...) \
     73  INTERNAL_TRACE_IGNORE(category, name)
     74 #define TRACE_EVENT_END(category, ...) INTERNAL_TRACE_IGNORE(category)
     75 #define TRACE_EVENT(category, name, ...) INTERNAL_TRACE_IGNORE(category, name)
     76 #define TRACE_EVENT_INSTANT(category, name, ...) \
     77  INTERNAL_TRACE_IGNORE(category, name)
     78 #define PERFETTO_INTERNAL_ADD_EMPTY_EVENT() INTERNAL_TRACE_IGNORE()
     79 
     80 namespace base {
     81 namespace trace_event {
     82 
     83 class BASE_EXPORT ConvertableToTraceFormat {
     84 public:
     85  ConvertableToTraceFormat() = default;
     86  ConvertableToTraceFormat(const ConvertableToTraceFormat&) = delete;
     87  ConvertableToTraceFormat& operator=(const ConvertableToTraceFormat&) = delete;
     88  virtual ~ConvertableToTraceFormat();
     89 
     90  // Append the class info to the provided |out| string. The appended
     91  // data must be a valid JSON object. Strings must be properly quoted, and
     92  // escaped. There is no processing applied to the content after it is
     93  // appended.
     94  virtual void AppendAsTraceFormat(std::string* out) const = 0;
     95 };
     96 
     97 class BASE_EXPORT TracedValue : public ConvertableToTraceFormat {
     98 public:
     99  explicit TracedValue(size_t capacity = 0) {}
    100 
    101  void EndDictionary() {}
    102  void EndArray() {}
    103 
    104  void SetInteger(const char* name, int value) {}
    105  void SetDouble(const char* name, double value) {}
    106  void SetBoolean(const char* name, bool value) {}
    107  void SetString(const char* name, base::StringPiece value) {}
    108  void SetValue(const char* name, TracedValue* value) {}
    109  void BeginDictionary(const char* name) {}
    110  void BeginArray(const char* name) {}
    111 
    112  void SetIntegerWithCopiedName(base::StringPiece name, int value) {}
    113  void SetDoubleWithCopiedName(base::StringPiece name, double value) {}
    114  void SetBooleanWithCopiedName(base::StringPiece name, bool value) {}
    115  void SetStringWithCopiedName(base::StringPiece name,
    116                               base::StringPiece value) {}
    117  void SetValueWithCopiedName(base::StringPiece name, TracedValue* value) {}
    118  void BeginDictionaryWithCopiedName(base::StringPiece name) {}
    119  void BeginArrayWithCopiedName(base::StringPiece name) {}
    120 
    121  void AppendInteger(int) {}
    122  void AppendDouble(double) {}
    123  void AppendBoolean(bool) {}
    124  void AppendString(base::StringPiece) {}
    125  void BeginArray() {}
    126  void BeginDictionary() {}
    127 
    128  void AppendAsTraceFormat(std::string* out) const override;
    129 };
    130 
    131 #if !defined(MOZ_SANDBOX)
    132 class BASE_EXPORT TracedValueJSON : public TracedValue {
    133 public:
    134  explicit TracedValueJSON(size_t capacity = 0) : TracedValue(capacity) {}
    135 
    136  std::unique_ptr<base::Value> ToBaseValue() const { return nullptr; }
    137  std::string ToJSON() const { return ""; }
    138  std::string ToFormattedJSON() const { return ""; }
    139 };
    140 #endif
    141 
    142 struct MemoryDumpArgs;
    143 class ProcessMemoryDump;
    144 
    145 class BASE_EXPORT MemoryDumpProvider {
    146 public:
    147  MemoryDumpProvider(const MemoryDumpProvider&) = delete;
    148  MemoryDumpProvider& operator=(const MemoryDumpProvider&) = delete;
    149  virtual ~MemoryDumpProvider();
    150 
    151  virtual bool OnMemoryDump(const MemoryDumpArgs& args,
    152                            ProcessMemoryDump* pmd) = 0;
    153 
    154 protected:
    155  MemoryDumpProvider() = default;
    156 };
    157 
    158 class BASE_EXPORT MemoryDumpManager {
    159 public:
    160  static constexpr const char* const kTraceCategory =
    161      TRACE_DISABLED_BY_DEFAULT("memory-infra");
    162 };
    163 
    164 inline uint64_t GetNextGlobalTraceId() {
    165  return 0;
    166 }
    167 
    168 }  // namespace trace_event
    169 }  // namespace base
    170 
    171 // Stub implementation for
    172 // perfetto::StaticString/ThreadTrack/TracedValue/TracedDictionary/TracedArray/
    173 // Track.
    174 namespace perfetto {
    175 
    176 class TracedArray;
    177 class TracedDictionary;
    178 class EventContext;
    179 
    180 class StaticString {
    181 public:
    182  template <typename T>
    183  StaticString(T) {}
    184 };
    185 
    186 class DynamicString {
    187 public:
    188  template <typename T>
    189  explicit DynamicString(T) {}
    190 };
    191 
    192 class TracedValue {
    193 public:
    194  void WriteInt64(int64_t) && {}
    195  void WriteUInt64(uint64_t) && {}
    196  void WriteDouble(double) && {}
    197  void WriteBoolean(bool) && {}
    198  void WriteString(const char*) && {}
    199  void WriteString(const char*, size_t) && {}
    200  void WriteString(const std::string&) && {}
    201  void WritePointer(const void*) && {}
    202 
    203  TracedDictionary WriteDictionary() &&;
    204  TracedArray WriteArray() &&;
    205 };
    206 
    207 class TracedDictionary {
    208 public:
    209  TracedValue AddItem(StaticString) { return TracedValue(); }
    210  TracedValue AddItem(DynamicString) { return TracedValue(); }
    211 
    212  template <typename T>
    213  void Add(StaticString, T&&) {}
    214  template <typename T>
    215  void Add(DynamicString, T&&) {}
    216 
    217  TracedDictionary AddDictionary(StaticString);
    218  TracedDictionary AddDictionary(DynamicString);
    219  TracedArray AddArray(StaticString);
    220  TracedArray AddArray(DynamicString);
    221 };
    222 
    223 class TracedArray {
    224 public:
    225  TracedValue AppendItem() { return TracedValue(); }
    226 
    227  template <typename T>
    228  void Append(T&&) {}
    229 
    230  TracedDictionary AppendDictionary();
    231  TracedArray AppendArray();
    232 };
    233 
    234 template <class T>
    235 void WriteIntoTracedValue(TracedValue, T&&) {}
    236 
    237 struct Track {
    238  explicit Track(uint64_t id) {}
    239 };
    240 
    241 namespace protos::pbzero {
    242 namespace SequenceManagerTask {
    243 
    244 enum class QueueName {
    245  UNKNOWN_TQ = 0,
    246  DEFAULT_TQ = 1,
    247  TASK_ENVIRONMENT_DEFAULT_TQ = 2,
    248  TEST2_TQ = 3,
    249  TEST_TQ = 4,
    250 };
    251 inline const char* QueueName_Name(QueueName value) {
    252  switch (value) {
    253    case QueueName::UNKNOWN_TQ:
    254      return "UNKNOWN_TQ";
    255    case QueueName::DEFAULT_TQ:
    256      return "DEFAULT_TQ";
    257    case QueueName::TASK_ENVIRONMENT_DEFAULT_TQ:
    258      return "TASK_ENVIRONMENT_DEFAULT_TQ";
    259    case QueueName::TEST2_TQ:
    260      return "TEST2_TQ";
    261    case QueueName::TEST_TQ:
    262      return "TEST_TQ";
    263  }
    264 }
    265 
    266 }  // namespace SequenceManagerTask
    267 
    268 namespace ChromeProcessDescriptor {
    269 
    270 enum ProcessType {};
    271 
    272 }  // namespace ChromeProcessDescriptor
    273 
    274 }  // namespace protos::pbzero
    275 }  // namespace perfetto
    276 
    277 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_STUB_H_