bcarrella
/
cef
mirror of https://bitbucket.org/chromiumembedded/cef
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove TRACE_EVENT_COPY_XXX overloads (fixes #3497) 

This functionality is not compatible with Chromium's new tracing implementation
based on Perfetto.
This commit is contained in:
Marshall Greenblatt 2023-05-08 13:03:41 +03:00
parent cf14b2a972
commit b8e1c6a59d
7 changed files with 120 additions and 494 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
include/base/cef_trace_event.h
View File

@ -145,14 +145,6 @@
/// free(str); // Trace system now has dangling pointer
/// </pre>
///
/// To avoid this issue with the |name| and |arg_name| parameters, use the
/// TRACE_EVENT_COPY_XXX overloads of the macros at additional runtime
/// overhead.
///
/// Notes: The category must always be in a long-lived char* (i.e. static
/// const). The |arg_values|, when used, are always deep copied with
/// the _COPY macros.
///
///
/// Thread Safety:
/// All macros are thread safe and can be used from any process.
@ -179,15 +171,15 @@
/// - category and name strings must have application lifetime (statics or
/// literals). They may not include " chars.
///
#define TRACE_EVENT0(category, name) \
cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false); \
#define TRACE_EVENT0(category, name) \
cef_trace_event_begin(category, name, NULL, 0, NULL, 0); \
CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
#define TRACE_EVENT1(category, name, arg1_name, arg1_val) \
cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false); \
#define TRACE_EVENT1(category, name, arg1_name, arg1_val) \
cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0); \
CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
#define TRACE_EVENT2(category, name, arg1_name, arg1_val, arg2_name, arg2_val) \
cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val, false); \
arg2_val); \
CEF_INTERNAL_TRACE_END_ON_SCOPE_CLOSE(category, name)
// Implementation detail: trace event macros create temporary variable names.
@ -211,21 +203,13 @@
/// literals). They may not include " chars.
///
#define TRACE_EVENT_INSTANT0(category, name) \
cef_trace_event_instant(category, name, NULL, 0, NULL, 0, false)
cef_trace_event_instant(category, name, NULL, 0, NULL, 0)
#define TRACE_EVENT_INSTANT1(category, name, arg1_name, arg1_val) \
cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, false)
cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0)
#define TRACE_EVENT_INSTANT2(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val) \
cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val, false)
#define TRACE_EVENT_COPY_INSTANT0(category, name) \
cef_trace_event_instant(category, name, NULL, 0, NULL, 0, true)
#define TRACE_EVENT_COPY_INSTANT1(category, name, arg1_name, arg1_val) \
cef_trace_event_instant(category, name, arg1_name, arg1_val, NULL, 0, true)
#define TRACE_EVENT_COPY_INSTANT2(category, name, arg1_name, arg1_val, \
arg2_name, arg2_val) \
cef_trace_event_instant(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val, true)
arg2_val)
///
/// Records a single BEGIN event called "name" immediately, with 0, 1 or 2
@ -235,21 +219,13 @@
/// literals). They may not include " chars.
///
#define TRACE_EVENT_BEGIN0(category, name) \
cef_trace_event_begin(category, name, NULL, 0, NULL, 0, false)
cef_trace_event_begin(category, name, NULL, 0, NULL, 0)
#define TRACE_EVENT_BEGIN1(category, name, arg1_name, arg1_val) \
cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, false)
cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0)
#define TRACE_EVENT_BEGIN2(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val) \
cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val, false)
#define TRACE_EVENT_COPY_BEGIN0(category, name) \
cef_trace_event_begin(category, name, NULL, 0, NULL, 0, true)
#define TRACE_EVENT_COPY_BEGIN1(category, name, arg1_name, arg1_val) \
cef_trace_event_begin(category, name, arg1_name, arg1_val, NULL, 0, true)
#define TRACE_EVENT_COPY_BEGIN2(category, name, arg1_name, arg1_val, \
arg2_name, arg2_val) \
cef_trace_event_begin(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val, true)
arg2_val)
///
/// Records a single END event for "name" immediately. If the category
@ -258,21 +234,12 @@
/// literals). They may not include " chars.
///
#define TRACE_EVENT_END0(category, name) \
cef_trace_event_end(category, name, NULL, 0, NULL, 0, false)
cef_trace_event_end(category, name, NULL, 0, NULL, 0)
#define TRACE_EVENT_END1(category, name, arg1_name, arg1_val) \
cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, false)
cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0)
#define TRACE_EVENT_END2(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val) \
cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val, false)
#define TRACE_EVENT_COPY_END0(category, name) \
cef_trace_event_end(category, name, NULL, 0, NULL, 0, true)
#define TRACE_EVENT_COPY_END1(category, name, arg1_name, arg1_val) \
cef_trace_event_end(category, name, arg1_name, arg1_val, NULL, 0, true)
#define TRACE_EVENT_COPY_END2(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val) \
cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, \
arg2_val, true)
cef_trace_event_end(category, name, arg1_name, arg1_val, arg2_name, arg2_val)
///
/// Records the value of a counter called "name" immediately. Value
@ -281,9 +248,7 @@
/// literals). They may not include " chars.
///
#define TRACE_COUNTER1(category, name, value) \
cef_trace_counter(category, name, NULL, value, NULL, 0, false)
#define TRACE_COPY_COUNTER1(category, name, value) \
cef_trace_counter(category, name, NULL, value, NULL, 0, true)
cef_trace_counter(category, name, NULL, value, NULL, 0)
///
/// Records the values of a multi-parted counter called "name" immediately.
@ -295,11 +260,7 @@
#define TRACE_COUNTER2(category, name, value1_name, value1_val, value2_name, \
value2_val) \
cef_trace_counter(category, name, value1_name, value1_val, value2_name, \
value2_val, false)
#define TRACE_COPY_COUNTER2(category, name, value1_name, value1_val, \
value2_name, value2_val) \
cef_trace_counter(category, name, value1_name, value1_val, value2_name, \
value2_val, true)
value2_val)
///
/// Records the value of a counter called "name" immediately. Value
@ -312,9 +273,7 @@
/// on two different processes will not collide.
///
#define TRACE_COUNTER_ID1(category, name, id, value) \
cef_trace_counter_id(category, name, id, NULL, value, NULL, 0, false)
#define TRACE_COPY_COUNTER_ID1(category, name, id, value) \
cef_trace_counter_id(category, name, id, NULL, value, NULL, 0, true)
cef_trace_counter_id(category, name, id, NULL, value, NULL, 0)
///
/// Records the values of a multi-parted counter called "name" immediately.
@ -330,11 +289,7 @@
#define TRACE_COUNTER_ID2(category, name, id, value1_name, value1_val, \
value2_name, value2_val) \
cef_trace_counter_id(category, name, id, value1_name, value1_val, \
value2_name, value2_val, false)
#define TRACE_COPY_COUNTER_ID2(category, name, id, value1_name, value1_val, \
value2_name, value2_val) \
cef_trace_counter_id(category, name, id, value1_name, value1_val, \
value2_name, value2_val, true)
value2_name, value2_val)
///
/// Records a single ASYNC_BEGIN event called "name" immediately, with 0, 1 or 2
@ -355,23 +310,13 @@
/// args.
///
#define TRACE_EVENT_ASYNC_BEGIN0(category, name, id) \
cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, false)
#define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, \
0, false)
cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0)
#define TRACE_EVENT_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, 0)
#define TRACE_EVENT_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \
arg2_name, arg2_val) \
cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, \
arg2_name, arg2_val, false)
#define TRACE_EVENT_COPY_ASYNC_BEGIN0(category, name, id) \
cef_trace_event_async_begin(category, name, id, NULL, 0, NULL, 0, true)
#define TRACE_EVENT_COPY_ASYNC_BEGIN1(category, name, id, arg1_name, arg1_val) \
cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, NULL, \
0, true)
#define TRACE_EVENT_COPY_ASYNC_BEGIN2(category, name, id, arg1_name, arg1_val, \
arg2_name, arg2_val) \
cef_trace_event_async_begin(category, name, id, arg1_name, arg1_val, \
arg2_name, arg2_val, true)
arg2_name, arg2_val)
///
/// Records a single ASYNC_STEP_INTO event for |step| immediately. If the
@ -382,17 +327,10 @@
/// ASYNC_STEP_PAST events.
///
#define TRACE_EVENT_ASYNC_STEP_INTO0(category, name, id, step) \
cef_trace_event_async_step_into(category, name, id, step, NULL, 0, false)
cef_trace_event_async_step_into(category, name, id, step, NULL, 0)
#define TRACE_EVENT_ASYNC_STEP_INTO1(category, name, id, step, arg1_name, \
arg1_val) \
cef_trace_event_async_step_into(category, name, id, step, arg1_name, \
arg1_val, false)
#define TRACE_EVENT_COPY_ASYNC_STEP_INTO0(category, name, id, step) \
cef_trace_event_async_step_into(category, name, id, step, NULL, 0, true)
#define TRACE_EVENT_COPY_ASYNC_STEP_INTO1(category, name, id, step, arg1_name, \
arg1_val) \
cef_trace_event_async_step_into(category, name, id, step, arg1_name, \
arg1_val, true)
cef_trace_event_async_step_into(category, name, id, step, arg1_name, arg1_val)
///
/// Records a single ASYNC_STEP_PAST event for |step| immediately. If the
@ -403,40 +341,23 @@
/// ASYNC_STEP_INTO events.
///
#define TRACE_EVENT_ASYNC_STEP_PAST0(category, name, id, step) \
cef_trace_event_async_step_past(category, name, id, step, NULL, 0, false)
cef_trace_event_async_step_past(category, name, id, step, NULL, 0)
#define TRACE_EVENT_ASYNC_STEP_PAST1(category, name, id, step, arg1_name, \
arg1_val) \
cef_trace_event_async_step_past(category, name, id, step, arg1_name, \
arg1_val, false)
#define TRACE_EVENT_COPY_ASYNC_STEP_PAST0(category, name, id, step) \
cef_trace_event_async_step_past(category, name, id, step, NULL, 0, true)
#define TRACE_EVENT_COPY_ASYNC_STEP_PAST1(category, name, id, step, arg1_name, \
arg1_val) \
cef_trace_event_async_step_past(category, name, id, step, arg1_name, \
arg1_val, true)
cef_trace_event_async_step_past(category, name, id, step, arg1_name, arg1_val)
///
/// Records a single ASYNC_END event for "name" immediately. If the category
/// is not enabled, then this does nothing.
///
#define TRACE_EVENT_ASYNC_END0(category, name, id) \
cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, false)
#define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val) \
cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \
false)
cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0)
#define TRACE_EVENT_ASYNC_END1(category, name, id, arg1_name, arg1_val) \
cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0)
#define TRACE_EVENT_ASYNC_END2(category, name, id, arg1_name, arg1_val, \
arg2_name, arg2_val) \
cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, \
arg2_name, arg2_val, false)
#define TRACE_EVENT_COPY_ASYNC_END0(category, name, id) \
cef_trace_event_async_end(category, name, id, NULL, 0, NULL, 0, true)
#define TRACE_EVENT_COPY_ASYNC_END1(category, name, id, arg1_name, arg1_val) \
cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, NULL, 0, \
true)
#define TRACE_EVENT_COPY_ASYNC_END2(category, name, id, arg1_name, arg1_val, \
arg2_name, arg2_val) \
cef_trace_event_async_end(category, name, id, arg1_name, arg1_val, \
arg2_name, arg2_val, true)
arg2_name, arg2_val)
namespace cef_trace_event {
@ -448,7 +369,7 @@ class CefTraceEndOnScopeClose {
CefTraceEndOnScopeClose(const char* category, const char* name)
: category_(category), name_(name) {}
~CefTraceEndOnScopeClose() {
cef_trace_event_end(category_, name_, NULL, 0, NULL, 0, false);
cef_trace_event_end(category_, name_, NULL, 0, NULL, 0);
}
private:

8
include/cef_api_hash.h
View File

@ -42,13 +42,13 @@
// way that may cause binary incompatibility with other builds. The universal
// hash value will change if any platform is affected whereas the platform hash
// values will change only if that particular platform is affected.
#define CEF_API_HASH_UNIVERSAL "defb610a3c797b3636da085bd008fb24c46c8242"
#define CEF_API_HASH_UNIVERSAL "cd16e1ab288ddddc4c13c67b05aed49a47db6e7f"
#if defined(OS_WIN)
#define CEF_API_HASH_PLATFORM "b47966e88841b7aa5546ead8a2021892d51886b1"
#define CEF_API_HASH_PLATFORM "d80ddfd6897163f83a0acdc2a3d3e627916a1365"
#elif defined(OS_MAC)
#define CEF_API_HASH_PLATFORM "da69054d32deecf2476aeb30607036e074413730"
#define CEF_API_HASH_PLATFORM "d19854c113f1549904ff4055f3a38901cac6af68"
#elif defined(OS_LINUX)
#define CEF_API_HASH_PLATFORM "00ed1b02f30b01ed1c841e1ef515f1b77f9832e6"
#define CEF_API_HASH_PLATFORM "0ba21a432d3b28ab79a0319a11a6e113ff1fcb07"
#endif
#ifdef __cplusplus

29
include/internal/cef_trace_event_internal.h
View File

@ -45,8 +45,6 @@ extern "C" {
// may not include "(quotes) chars.
// - |argX_name|, |argX_val|, |valueX_name|, |valeX_val| are optional parameters
// and represent pairs of name and values of arguments
// - |copy| is used to avoid memory scoping issues with the |name| and
// |arg_name| parameters by copying them
// - |id| is used to disambiguate counters with the same name, or match async
// trace events
@ -55,67 +53,58 @@ CEF_EXPORT void cef_trace_event_instant(const char* category,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy);
uint64 arg2_val);
CEF_EXPORT void cef_trace_event_begin(const char* category,
const char* name,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy);
uint64 arg2_val);
CEF_EXPORT void cef_trace_event_end(const char* category,
const char* name,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy);
uint64 arg2_val);
CEF_EXPORT void cef_trace_counter(const char* category,
const char* name,
const char* value1_name,
uint64 value1_val,
const char* value2_name,
uint64 value2_val,
int copy);
uint64 value2_val);
CEF_EXPORT void cef_trace_counter_id(const char* category,
const char* name,
uint64 id,
const char* value1_name,
uint64 value1_val,
const char* value2_name,
uint64 value2_val,
int copy);
uint64 value2_val);
CEF_EXPORT void cef_trace_event_async_begin(const char* category,
const char* name,
uint64 id,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy);
uint64 arg2_val);
CEF_EXPORT void cef_trace_event_async_step_into(const char* category,
const char* name,
uint64 id,
uint64 step,
const char* arg1_name,
uint64 arg1_val,
int copy);
uint64 arg1_val);
CEF_EXPORT void cef_trace_event_async_step_past(const char* category,
const char* name,
uint64 id,
uint64 step,
const char* arg1_name,
uint64 arg1_val,
int copy);
uint64 arg1_val);
CEF_EXPORT void cef_trace_event_async_end(const char* category,
const char* name,
uint64 id,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy);
uint64 arg2_val);
#ifdef __cplusplus
}

220
libcef/common/base_impl.cc
View File

@ -23,33 +23,20 @@ CEF_EXPORT void cef_trace_event_instant(const char* /* category */,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy) {
uint64 arg2_val) {
DCHECK(name);
if (!name) {
return;
}
if (copy) {
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_COPY_INSTANT0(kCategory, name, TRACE_EVENT_SCOPE_THREAD);
} else if (arg2_name == nullptr) {
TRACE_EVENT_COPY_INSTANT1(kCategory, name, TRACE_EVENT_SCOPE_THREAD,
arg1_name, arg1_val);
} else {
TRACE_EVENT_COPY_INSTANT2(kCategory, name, TRACE_EVENT_SCOPE_THREAD,
arg1_name, arg1_val, arg2_name, arg2_val);
}
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_INSTANT0(kCategory, name, TRACE_EVENT_SCOPE_THREAD);
} else if (arg2_name == nullptr) {
TRACE_EVENT_INSTANT1(kCategory, name, TRACE_EVENT_SCOPE_THREAD, arg1_name,
arg1_val);
} else {
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_INSTANT0(kCategory, name, TRACE_EVENT_SCOPE_THREAD);
} else if (arg2_name == nullptr) {
TRACE_EVENT_INSTANT1(kCategory, name, TRACE_EVENT_SCOPE_THREAD, arg1_name,
arg1_val);
} else {
TRACE_EVENT_INSTANT2(kCategory, name, TRACE_EVENT_SCOPE_THREAD, arg1_name,
arg1_val, arg2_name, arg2_val);
}
TRACE_EVENT_INSTANT2(kCategory, name, TRACE_EVENT_SCOPE_THREAD, arg1_name,
arg1_val, arg2_name, arg2_val);
}
}
@ -58,32 +45,19 @@ CEF_EXPORT void cef_trace_event_begin(const char* /* category */,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy) {
uint64 arg2_val) {
DCHECK(name);
if (!name) {
return;
}
if (copy) {
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_BEGIN_WITH_FLAGS0(kCategory, name, TRACE_EVENT_FLAG_COPY);
} else if (arg2_name == nullptr) {
TRACE_EVENT_BEGIN_WITH_FLAGS1(kCategory, name, TRACE_EVENT_FLAG_COPY,
arg1_name, arg1_val);
} else {
TRACE_EVENT_COPY_BEGIN2(kCategory, name, arg1_name, arg1_val, arg2_name,
arg2_val);
}
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_BEGIN0(kCategory, name);
} else if (arg2_name == nullptr) {
TRACE_EVENT_BEGIN1(kCategory, name, arg1_name, arg1_val);
} else {
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_BEGIN0(kCategory, name);
} else if (arg2_name == nullptr) {
TRACE_EVENT_BEGIN1(kCategory, name, arg1_name, arg1_val);
} else {
TRACE_EVENT_BEGIN2(kCategory, name, arg1_name, arg1_val, arg2_name,
arg2_val);
}
TRACE_EVENT_BEGIN2(kCategory, name, arg1_name, arg1_val, arg2_name,
arg2_val);
}
}
@ -92,32 +66,18 @@ CEF_EXPORT void cef_trace_event_end(const char* /* category */,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy) {
uint64 arg2_val) {
DCHECK(name);
if (!name) {
return;
}
if (copy) {
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_END_WITH_FLAGS0(kCategory, name, TRACE_EVENT_FLAG_COPY);
} else if (arg2_name == nullptr) {
TRACE_EVENT_END_WITH_FLAGS1(kCategory, name, TRACE_EVENT_FLAG_COPY,
arg1_name, arg1_val);
} else {
TRACE_EVENT_COPY_END2(kCategory, name, arg1_name, arg1_val, arg2_name,
arg2_val);
}
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_END0(kCategory, name);
} else if (arg2_name == nullptr) {
TRACE_EVENT_END1(kCategory, name, arg1_name, arg1_val);
} else {
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_END0(kCategory, name);
} else if (arg2_name == nullptr) {
TRACE_EVENT_END1(kCategory, name, arg1_name, arg1_val);
} else {
TRACE_EVENT_END2(kCategory, name, arg1_name, arg1_val, arg2_name,
arg2_val);
}
TRACE_EVENT_END2(kCategory, name, arg1_name, arg1_val, arg2_name, arg2_val);
}
}
@ -126,27 +86,17 @@ CEF_EXPORT void cef_trace_counter(const char* /* category */,
const char* value1_name,
uint64 value1_val,
const char* value2_name,
uint64 value2_val,
int copy) {
uint64 value2_val) {
DCHECK(name);
if (!name) {
return;
}
if (copy) {
if (value1_name == nullptr && value2_name == nullptr) {
TRACE_COPY_COUNTER1(kCategory, name, value1_val);
} else {
TRACE_COPY_COUNTER2(kCategory, name, value1_name, value1_val, value2_name,
value2_val);
}
if (value1_name == nullptr && value2_name == nullptr) {
TRACE_COUNTER1(kCategory, name, value1_val);
} else {
if (value1_name == nullptr && value2_name == nullptr) {
TRACE_COUNTER1(kCategory, name, value1_val);
} else {
TRACE_COUNTER2(kCategory, name, value1_name, value1_val, value2_name,
value2_val);
}
TRACE_COUNTER2(kCategory, name, value1_name, value1_val, value2_name,
value2_val);
}
}
@ -156,27 +106,17 @@ CEF_EXPORT void cef_trace_counter_id(const char* /* category */,
const char* value1_name,
uint64 value1_val,
const char* value2_name,
uint64 value2_val,
int copy) {
uint64 value2_val) {
DCHECK(name);
if (!name) {
return;
}
if (copy) {
if (value1_name == nullptr && value2_name == nullptr) {
TRACE_COPY_COUNTER_ID1(kCategory, name, id, value1_val);
} else {
TRACE_COPY_COUNTER_ID2(kCategory, name, id, value1_name, value1_val,
value2_name, value2_val);
}
if (value1_name == nullptr && value2_name == nullptr) {
TRACE_COUNTER_ID1(kCategory, name, id, value1_val);
} else {
if (value1_name == nullptr && value2_name == nullptr) {
TRACE_COUNTER_ID1(kCategory, name, id, value1_val);
} else {
TRACE_COUNTER_ID2(kCategory, name, id, value1_name, value1_val,
value2_name, value2_val);
}
TRACE_COUNTER_ID2(kCategory, name, id, value1_name, value1_val, value2_name,
value2_val);
}
}
@ -186,31 +126,19 @@ CEF_EXPORT void cef_trace_event_async_begin(const char* /* category */,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy) {
uint64 arg2_val) {
DCHECK(name);
if (!name) {
return;
}
if (copy) {
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_COPY_ASYNC_BEGIN0(kCategory, name, id);
} else if (arg2_name == nullptr) {
TRACE_EVENT_COPY_ASYNC_BEGIN1(kCategory, name, id, arg1_name, arg1_val);
} else {
TRACE_EVENT_COPY_ASYNC_BEGIN2(kCategory, name, id, arg1_name, arg1_val,
arg2_name, arg2_val);
}
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_ASYNC_BEGIN0(kCategory, name, id);
} else if (arg2_name == nullptr) {
TRACE_EVENT_ASYNC_BEGIN1(kCategory, name, id, arg1_name, arg1_val);
} else {
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_ASYNC_BEGIN0(kCategory, name, id);
} else if (arg2_name == nullptr) {
TRACE_EVENT_ASYNC_BEGIN1(kCategory, name, id, arg1_name, arg1_val);
} else {
TRACE_EVENT_ASYNC_BEGIN2(kCategory, name, id, arg1_name, arg1_val,
arg2_name, arg2_val);
}
TRACE_EVENT_ASYNC_BEGIN2(kCategory, name, id, arg1_name, arg1_val,
arg2_name, arg2_val);
}
}
@ -219,30 +147,17 @@ CEF_EXPORT void cef_trace_event_async_step_into(const char* /* category */,
uint64 id,
uint64 step,
const char* arg1_name,
uint64 arg1_val,
int copy) {
uint64 arg1_val) {
DCHECK(name);
if (!name) {
return;
}
if (copy) {
if (arg1_name == nullptr) {
INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_INTO,
kCategory, name, id,
TRACE_EVENT_FLAG_COPY, "step", step);
} else {
INTERNAL_TRACE_EVENT_ADD_WITH_ID(
TRACE_EVENT_PHASE_ASYNC_STEP_INTO, kCategory, name, id,
TRACE_EVENT_FLAG_COPY, "step", step, arg1_name, arg1_val);
}
if (arg1_name == nullptr) {
TRACE_EVENT_ASYNC_STEP_INTO0(kCategory, name, id, step);
} else {
if (arg1_name == nullptr) {
TRACE_EVENT_ASYNC_STEP_INTO0(kCategory, name, id, step);
} else {
TRACE_EVENT_ASYNC_STEP_INTO1(kCategory, name, id, step, arg1_name,
arg1_val);
}
TRACE_EVENT_ASYNC_STEP_INTO1(kCategory, name, id, step, arg1_name,
arg1_val);
}
}
@ -251,30 +166,17 @@ CEF_EXPORT void cef_trace_event_async_step_past(const char* /* category */,
uint64 id,
uint64 step,
const char* arg1_name,
uint64 arg1_val,
int copy) {
uint64 arg1_val) {
DCHECK(name);
if (!name) {
return;
}
if (copy) {
if (arg1_name == nullptr) {
INTERNAL_TRACE_EVENT_ADD_WITH_ID(TRACE_EVENT_PHASE_ASYNC_STEP_PAST,
kCategory, name, id,
TRACE_EVENT_FLAG_COPY, "step", step);
} else {
INTERNAL_TRACE_EVENT_ADD_WITH_ID(
TRACE_EVENT_PHASE_ASYNC_STEP_PAST, kCategory, name, id,
TRACE_EVENT_FLAG_COPY, "step", step, arg1_name, arg1_val);
}
if (arg1_name == nullptr) {
TRACE_EVENT_ASYNC_STEP_PAST0(kCategory, name, id, step);
} else {
if (arg1_name == nullptr) {
TRACE_EVENT_ASYNC_STEP_PAST0(kCategory, name, id, step);
} else {
TRACE_EVENT_ASYNC_STEP_PAST1(kCategory, name, id, step, arg1_name,
arg1_val);
}
TRACE_EVENT_ASYNC_STEP_PAST1(kCategory, name, id, step, arg1_name,
arg1_val);
}
}
@ -284,31 +186,19 @@ CEF_EXPORT void cef_trace_event_async_end(const char* /* category */,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy) {
uint64 arg2_val) {
DCHECK(name);
if (!name) {
return;
}
if (copy) {
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_COPY_ASYNC_END0(kCategory, name, id);
} else if (arg2_name == nullptr) {
TRACE_EVENT_COPY_ASYNC_END1(kCategory, name, id, arg1_name, arg1_val);
} else {
TRACE_EVENT_COPY_ASYNC_END2(kCategory, name, id, arg1_name, arg1_val,
arg2_name, arg2_val);
}
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_ASYNC_END0(kCategory, name, id);
} else if (arg2_name == nullptr) {
TRACE_EVENT_ASYNC_END1(kCategory, name, id, arg1_name, arg1_val);
} else {
if (arg1_name == nullptr && arg2_name == nullptr) {
TRACE_EVENT_ASYNC_END0(kCategory, name, id);
} else if (arg2_name == nullptr) {
TRACE_EVENT_ASYNC_END1(kCategory, name, id, arg1_name, arg1_val);
} else {
TRACE_EVENT_ASYNC_END2(kCategory, name, id, arg1_name, arg1_val,
arg2_name, arg2_val);
}
TRACE_EVENT_ASYNC_END2(kCategory, name, id, arg1_name, arg1_val, arg2_name,
arg2_val);
}
}

52
libcef_dll/wrapper/libcef_dll_dylib.cc
View File

@ -9,7 +9,7 @@
// implementations. See the translator.README.txt file in the tools directory
// for more information.
//
// $hash=c3d95d65039cab3684964b164afe772d8a614f82$
// $hash=b974b66c129de2b11c6b3fe38a60f695e7d67edd$
//
#include <dlfcn.h>
@ -1709,10 +1709,9 @@ void cef_trace_event_instant(const char* category,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy) {
uint64 arg2_val) {
g_libcef_pointers.cef_trace_event_instant(category, name, arg1_name, arg1_val,
arg2_name, arg2_val, copy);
arg2_name, arg2_val);
}
NO_SANITIZE("cfi-icall")
@ -1721,10 +1720,9 @@ void cef_trace_event_begin(const char* category,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy) {
uint64 arg2_val) {
g_libcef_pointers.cef_trace_event_begin(category, name, arg1_name, arg1_val,
arg2_name, arg2_val, copy);
arg2_name, arg2_val);
}
NO_SANITIZE("cfi-icall")
@ -1733,10 +1731,9 @@ void cef_trace_event_end(const char* category,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy) {
uint64 arg2_val) {
g_libcef_pointers.cef_trace_event_end(category, name, arg1_name, arg1_val,
arg2_name, arg2_val, copy);
arg2_name, arg2_val);
}
NO_SANITIZE("cfi-icall")
@ -1745,10 +1742,9 @@ void cef_trace_counter(const char* category,
const char* value1_name,
uint64 value1_val,
const char* value2_name,
uint64 value2_val,
int copy) {
uint64 value2_val) {
g_libcef_pointers.cef_trace_counter(category, name, value1_name, value1_val,
value2_name, value2_val, copy);
value2_name, value2_val);
}
NO_SANITIZE("cfi-icall")
@ -1758,11 +1754,9 @@ void cef_trace_counter_id(const char* category,
const char* value1_name,
uint64 value1_val,
const char* value2_name,
uint64 value2_val,
int copy) {
uint64 value2_val) {
g_libcef_pointers.cef_trace_counter_id(category, name, id, value1_name,
value1_val, value2_name, value2_val,
copy);
value1_val, value2_name, value2_val);
}
NO_SANITIZE("cfi-icall")
@ -1772,10 +1766,9 @@ void cef_trace_event_async_begin(const char* category,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy) {
g_libcef_pointers.cef_trace_event_async_begin(
category, name, id, arg1_name, arg1_val, arg2_name, arg2_val, copy);
uint64 arg2_val) {
g_libcef_pointers.cef_trace_event_async_begin(category, name, id, arg1_name,
arg1_val, arg2_name, arg2_val);
}
NO_SANITIZE("cfi-icall")
@ -1784,10 +1777,9 @@ void cef_trace_event_async_step_into(const char* category,
uint64 id,
uint64 step,
const char* arg1_name,
uint64 arg1_val,
int copy) {
uint64 arg1_val) {
g_libcef_pointers.cef_trace_event_async_step_into(category, name, id, step,
arg1_name, arg1_val, copy);
arg1_name, arg1_val);
}
NO_SANITIZE("cfi-icall")
@ -1796,10 +1788,9 @@ void cef_trace_event_async_step_past(const char* category,
uint64 id,
uint64 step,
const char* arg1_name,
uint64 arg1_val,
int copy) {
uint64 arg1_val) {
g_libcef_pointers.cef_trace_event_async_step_past(category, name, id, step,
arg1_name, arg1_val, copy);
arg1_name, arg1_val);
}
NO_SANITIZE("cfi-icall")
@ -1809,8 +1800,7 @@ void cef_trace_event_async_end(const char* category,
const char* arg1_name,
uint64 arg1_val,
const char* arg2_name,
uint64 arg2_val,
int copy) {
g_libcef_pointers.cef_trace_event_async_end(
category, name, id, arg1_name, arg1_val, arg2_name, arg2_val, copy);
uint64 arg2_val) {
g_libcef_pointers.cef_trace_event_async_end(category, name, id, arg1_name,
arg1_val, arg2_name, arg2_val);
}

159
tests/ceftests/tracing_unittest.cc
View File

@ -23,49 +23,26 @@ enum TracingTestType {
TT_TRACE_EVENT_INSTANT0,
TT_TRACE_EVENT_INSTANT1,
TT_TRACE_EVENT_INSTANT2,
TT_TRACE_EVENT_COPY_INSTANT0,
TT_TRACE_EVENT_COPY_INSTANT1,
TT_TRACE_EVENT_COPY_INSTANT2,
TT_TRACE_EVENT_BEGIN0,
TT_TRACE_EVENT_BEGIN1,
TT_TRACE_EVENT_BEGIN2,
TT_TRACE_EVENT_COPY_BEGIN0,
TT_TRACE_EVENT_COPY_BEGIN1,
TT_TRACE_EVENT_COPY_BEGIN2,
TT_TRACE_EVENT_END0,
TT_TRACE_EVENT_END1,
TT_TRACE_EVENT_END2,
TT_TRACE_EVENT_COPY_END0,
TT_TRACE_EVENT_COPY_END1,
TT_TRACE_EVENT_COPY_END2,
TT_TRACE_COUNTER1,
TT_TRACE_COPY_COUNTER1,
TT_TRACE_COUNTER2,
TT_TRACE_COPY_COUNTER2,
TT_TRACE_COUNTER_ID1,
TT_TRACE_COPY_COUNTER_ID1,
TT_TRACE_COUNTER_ID2,
TT_TRACE_COPY_COUNTER_ID2,
TT_TRACE_EVENT_ASYNC_BEGIN0,
TT_TRACE_EVENT_ASYNC_BEGIN1,
TT_TRACE_EVENT_ASYNC_BEGIN2,
TT_TRACE_EVENT_COPY_ASYNC_BEGIN0,
TT_TRACE_EVENT_COPY_ASYNC_BEGIN1,
TT_TRACE_EVENT_COPY_ASYNC_BEGIN2,
TT_TRACE_EVENT_ASYNC_STEP_INTO0,
TT_TRACE_EVENT_ASYNC_STEP_INTO1,
TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO0,
TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO1,
TT_TRACE_EVENT_ASYNC_STEP_PAST0,
TT_TRACE_EVENT_ASYNC_STEP_PAST1,
TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST0,
TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST1,
TT_TRACE_EVENT_ASYNC_END0,
TT_TRACE_EVENT_ASYNC_END1,
TT_TRACE_EVENT_ASYNC_END2,
TT_TRACE_EVENT_COPY_ASYNC_END0,
TT_TRACE_EVENT_COPY_ASYNC_END1,
TT_TRACE_EVENT_COPY_ASYNC_END2
};
const char kTraceTestCategory[] = "cef.client";
@ -132,19 +109,6 @@ class TracingTestHandler : public CefEndTracingCallback,
TRACE_EVENT_INSTANT2(kTraceTestCategory, "TT_TRACE_EVENT_INSTANT2",
"arg1", 1, "arg2", 2);
break;
case TT_TRACE_EVENT_COPY_INSTANT0:
TRACE_EVENT_COPY_INSTANT0(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_INSTANT0");
break;
case TT_TRACE_EVENT_COPY_INSTANT1:
TRACE_EVENT_COPY_INSTANT1(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_INSTANT1", "arg1", 1);
break;
case TT_TRACE_EVENT_COPY_INSTANT2:
TRACE_EVENT_COPY_INSTANT2(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_INSTANT2", "arg1", 1,
"arg2", 2);
break;
case TT_TRACE_EVENT_BEGIN0:
TRACE_EVENT_BEGIN0(kTraceTestCategory, "TT_TRACE_EVENT_BEGIN0");
break;
@ -156,19 +120,6 @@ class TracingTestHandler : public CefEndTracingCallback,
TRACE_EVENT_BEGIN2(kTraceTestCategory, "TT_TRACE_EVENT_BEGIN2", "arg1",
1, "arg2", 2);
break;
case TT_TRACE_EVENT_COPY_BEGIN0:
TRACE_EVENT_COPY_BEGIN0(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_BEGIN0");
break;
case TT_TRACE_EVENT_COPY_BEGIN1:
TRACE_EVENT_COPY_BEGIN1(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_BEGIN1", "arg1", 1);
break;
case TT_TRACE_EVENT_COPY_BEGIN2:
TRACE_EVENT_COPY_BEGIN2(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_BEGIN2", "arg1", 1, "arg2",
2);
break;
case TT_TRACE_EVENT_END0:
TRACE_EVENT_BEGIN0(kTraceTestCategory, "TT_TRACE_EVENT_END0");
TRACE_EVENT_END0(kTraceTestCategory, "TT_TRACE_EVENT_END0");
@ -184,51 +135,20 @@ class TracingTestHandler : public CefEndTracingCallback,
TRACE_EVENT_END2(kTraceTestCategory, "TT_TRACE_EVENT_END2", "arg1", 1,
"arg2", 2);
break;
case TT_TRACE_EVENT_COPY_END0:
TRACE_EVENT_COPY_BEGIN0(kTraceTestCategory, "TT_TRACE_EVENT_COPY_END0");
TRACE_EVENT_COPY_END0(kTraceTestCategory, "TT_TRACE_EVENT_COPY_END0");
break;
case TT_TRACE_EVENT_COPY_END1:
TRACE_EVENT_COPY_BEGIN1(kTraceTestCategory, "TT_TRACE_EVENT_COPY_END1",
"arg1", 1);
TRACE_EVENT_COPY_END1(kTraceTestCategory, "TT_TRACE_EVENT_COPY_END1",
"arg1", 1);
break;
case TT_TRACE_EVENT_COPY_END2:
TRACE_EVENT_COPY_BEGIN2(kTraceTestCategory, "TT_TRACE_EVENT_COPY_END2",
"arg1", 1, "arg2", 2);
TRACE_EVENT_COPY_END2(kTraceTestCategory, "TT_TRACE_EVENT_COPY_END2",
"arg1", 1, "arg2", 2);
break;
case TT_TRACE_COUNTER1:
TRACE_COUNTER1(kTraceTestCategory, "TT_TRACE_COUNTER1", 5);
break;
case TT_TRACE_COPY_COUNTER1:
TRACE_COPY_COUNTER1(kTraceTestCategory, "TT_TRACE_COPY_COUNTER1", 5);
break;
case TT_TRACE_COUNTER2:
TRACE_COUNTER2(kTraceTestCategory, "TT_TRACE_COUNTER2", "val1", 5,
"val2", 10);
break;
case TT_TRACE_COPY_COUNTER2:
TRACE_COPY_COUNTER2(kTraceTestCategory, "TT_TRACE_COPY_COUNTER2",
"val1", 5, "val2", 10);
break;
case TT_TRACE_COUNTER_ID1:
TRACE_COUNTER_ID1(kTraceTestCategory, "TT_TRACE_COUNTER_ID1", 100, 5);
break;
case TT_TRACE_COPY_COUNTER_ID1:
TRACE_COPY_COUNTER_ID1(kTraceTestCategory, "TT_TRACE_COPY_COUNTER_ID1",
100, 5);
break;
case TT_TRACE_COUNTER_ID2:
TRACE_COUNTER_ID2(kTraceTestCategory, "TT_TRACE_COUNTER_ID2", 100,
"val1", 5, "val2", 10);
break;
case TT_TRACE_COPY_COUNTER_ID2:
TRACE_COPY_COUNTER_ID2(kTraceTestCategory, "TT_TRACE_COPY_COUNTER_ID2",
100, "val1", 5, "val2", 10);
break;
case TT_TRACE_EVENT_ASYNC_BEGIN0:
TRACE_EVENT_ASYNC_BEGIN0(kTraceTestCategory,
"TT_TRACE_EVENT_ASYNC_BEGIN0", 100);
@ -242,20 +162,6 @@ class TracingTestHandler : public CefEndTracingCallback,
"TT_TRACE_EVENT_ASYNC_BEGIN2", 100, "arg1", 1,
"arg2", 2);
break;
case TT_TRACE_EVENT_COPY_ASYNC_BEGIN0:
TRACE_EVENT_COPY_ASYNC_BEGIN0(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_ASYNC_BEGIN0", 100);
break;
case TT_TRACE_EVENT_COPY_ASYNC_BEGIN1:
TRACE_EVENT_COPY_ASYNC_BEGIN1(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_ASYNC_BEGIN1", 100,
"arg1", 1);
break;
case TT_TRACE_EVENT_COPY_ASYNC_BEGIN2:
TRACE_EVENT_COPY_ASYNC_BEGIN2(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_ASYNC_BEGIN2", 100,
"arg1", 1, "arg2", 2);
break;
case TT_TRACE_EVENT_ASYNC_STEP_INTO0:
TRACE_EVENT_ASYNC_STEP_INTO0(
kTraceTestCategory, "TT_TRACE_EVENT_ASYNC_STEP_INTO0", 100, 1000);
@ -265,16 +171,6 @@ class TracingTestHandler : public CefEndTracingCallback,
"TT_TRACE_EVENT_ASYNC_STEP_INTO1", 100,
1000, "arg1", 1);
break;
case TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO0:
TRACE_EVENT_COPY_ASYNC_STEP_INTO0(
kTraceTestCategory, "TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO0", 100,
1000);
break;
case TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO1:
TRACE_EVENT_COPY_ASYNC_STEP_INTO1(
kTraceTestCategory, "TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO1", 100,
1000, "arg1", 1);
break;
case TT_TRACE_EVENT_ASYNC_STEP_PAST0:
TRACE_EVENT_ASYNC_STEP_PAST0(
kTraceTestCategory, "TT_TRACE_EVENT_ASYNC_STEP_PAST0", 100, 1000);
@ -284,16 +180,6 @@ class TracingTestHandler : public CefEndTracingCallback,
"TT_TRACE_EVENT_ASYNC_STEP_PAST1", 100,
1000, "arg1", 1);
break;
case TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST0:
TRACE_EVENT_COPY_ASYNC_STEP_PAST0(
kTraceTestCategory, "TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST0", 100,
1000);
break;
case TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST1:
TRACE_EVENT_COPY_ASYNC_STEP_PAST1(
kTraceTestCategory, "TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST1", 100,
1000, "arg1", 1);
break;
case TT_TRACE_EVENT_ASYNC_END0:
TRACE_EVENT_ASYNC_BEGIN0(kTraceTestCategory,
"TT_TRACE_EVENT_ASYNC_END0", 100);
@ -313,28 +199,6 @@ class TracingTestHandler : public CefEndTracingCallback,
TRACE_EVENT_ASYNC_END2(kTraceTestCategory, "TT_TRACE_EVENT_ASYNC_END2",
100, "arg1", 1, "arg2", 2);
break;
case TT_TRACE_EVENT_COPY_ASYNC_END0:
TRACE_EVENT_COPY_ASYNC_BEGIN0(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_ASYNC_END0", 100);
TRACE_EVENT_COPY_ASYNC_END0(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_ASYNC_END0", 100);
break;
case TT_TRACE_EVENT_COPY_ASYNC_END1:
TRACE_EVENT_COPY_ASYNC_BEGIN1(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_ASYNC_END1", 100,
"arg1", 1);
TRACE_EVENT_COPY_ASYNC_END1(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_ASYNC_END1", 100,
"arg1", 1);
break;
case TT_TRACE_EVENT_COPY_ASYNC_END2:
TRACE_EVENT_COPY_ASYNC_BEGIN2(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_ASYNC_END2", 100,
"arg1", 1, "arg2", 2);
TRACE_EVENT_COPY_ASYNC_END2(kTraceTestCategory,
"TT_TRACE_EVENT_COPY_ASYNC_END2", 100,
"arg1", 1, "arg2", 2);
break;
}
// Results in a call to OnEndTracingComplete.
@ -386,49 +250,26 @@ TRACING_TEST(TraceEvent2, TT_TRACE_EVENT2)
TRACING_TEST(TraceEventInstant0, TT_TRACE_EVENT_INSTANT0)
TRACING_TEST(TraceEventInstant1, TT_TRACE_EVENT_INSTANT1)
TRACING_TEST(TraceEventInstant2, TT_TRACE_EVENT_INSTANT2)
TRACING_TEST(TraceEventCopyInstant0, TT_TRACE_EVENT_COPY_INSTANT0)
TRACING_TEST(TraceEventCopyInstant1, TT_TRACE_EVENT_COPY_INSTANT1)
TRACING_TEST(TraceEventCopyInstant2, TT_TRACE_EVENT_COPY_INSTANT2)
TRACING_TEST(TraceEventBegin0, TT_TRACE_EVENT_BEGIN0)
TRACING_TEST(TraceEventBegin1, TT_TRACE_EVENT_BEGIN1)
TRACING_TEST(TraceEventBegin2, TT_TRACE_EVENT_BEGIN2)
TRACING_TEST(TraceEventCopyBegin0, TT_TRACE_EVENT_COPY_BEGIN0)
TRACING_TEST(TraceEventCopyBegin1, TT_TRACE_EVENT_COPY_BEGIN1)
TRACING_TEST(TraceEventCopyBegin2, TT_TRACE_EVENT_COPY_BEGIN2)
TRACING_TEST(TraceEventEnd0, TT_TRACE_EVENT_END0)
TRACING_TEST(TraceEventEnd1, TT_TRACE_EVENT_END1)
TRACING_TEST(TraceEventEnd2, TT_TRACE_EVENT_END2)
TRACING_TEST(TraceEventCopyEnd0, TT_TRACE_EVENT_COPY_END0)
TRACING_TEST(TraceEventCopyEnd1, TT_TRACE_EVENT_COPY_END1)
TRACING_TEST(TraceEventCopyEnd2, TT_TRACE_EVENT_COPY_END1)
TRACING_TEST(TraceCounter1, TT_TRACE_COUNTER1)
TRACING_TEST(TraceCopyCounter1, TT_TRACE_COPY_COUNTER1)
TRACING_TEST(TraceCounter2, TT_TRACE_COUNTER2)
TRACING_TEST(TraceCopyCounter2, TT_TRACE_COPY_COUNTER2)
TRACING_TEST(TraceCounterId1, TT_TRACE_COUNTER_ID1)
TRACING_TEST(TraceCopyCounterId1, TT_TRACE_COPY_COUNTER_ID1)
TRACING_TEST(TraceCounterId2, TT_TRACE_COUNTER_ID2)
TRACING_TEST(TraceCopyCounterId2, TT_TRACE_COPY_COUNTER_ID1)
TRACING_TEST(TraceEventAsyncBegin0, TT_TRACE_EVENT_ASYNC_BEGIN0)
TRACING_TEST(TraceEventAsyncBegin1, TT_TRACE_EVENT_ASYNC_BEGIN1)
TRACING_TEST(TraceEventAsyncBegin2, TT_TRACE_EVENT_ASYNC_BEGIN2)
TRACING_TEST(TraceEventCopyAsyncBegin0, TT_TRACE_EVENT_COPY_ASYNC_BEGIN0)
TRACING_TEST(TraceEventCopyAsyncBegin1, TT_TRACE_EVENT_COPY_ASYNC_BEGIN1)
TRACING_TEST(TraceEventCopyAsyncBegin2, TT_TRACE_EVENT_COPY_ASYNC_BEGIN2)
TRACING_TEST(TraceEventAsyncStepInto0, TT_TRACE_EVENT_ASYNC_STEP_INTO0)
TRACING_TEST(TraceEventAsyncStepInto1, TT_TRACE_EVENT_ASYNC_STEP_INTO1)
TRACING_TEST(TraceEventCopyAsyncStepInto0, TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO0)
TRACING_TEST(TraceEventCopyAsyncStepInto1, TT_TRACE_EVENT_COPY_ASYNC_STEP_INTO1)
TRACING_TEST(TraceEventAsyncStepPast0, TT_TRACE_EVENT_ASYNC_STEP_PAST0)
TRACING_TEST(TraceEventAsyncStepPast1, TT_TRACE_EVENT_ASYNC_STEP_PAST1)
TRACING_TEST(TraceEventCopyAsyncStepPast0, TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST0)
TRACING_TEST(TraceEventCopyAsyncStepPast1, TT_TRACE_EVENT_COPY_ASYNC_STEP_PAST1)
TRACING_TEST(TraceEventAsyncEnd0, TT_TRACE_EVENT_ASYNC_END0)
TRACING_TEST(TraceEventAsyncEnd1, TT_TRACE_EVENT_ASYNC_END1)
TRACING_TEST(TraceEventAsyncEnd2, TT_TRACE_EVENT_ASYNC_END2)
TRACING_TEST(TraceEventCopyAsyncEnd0, TT_TRACE_EVENT_COPY_ASYNC_END0)
TRACING_TEST(TraceEventCopyAsyncEnd1, TT_TRACE_EVENT_COPY_ASYNC_END1)
TRACING_TEST(TraceEventCopyAsyncEnd2, TT_TRACE_EVENT_COPY_ASYNC_END2)
TEST(TracingTest, NowFromSystemTraceTime) {
int64 val = CefNowFromSystemTraceTime();

5
tools/gn_args.py
View File

@ -228,11 +228,6 @@ def GetRecommendedDefaultArgs():
# CefV8Value::CreateArrayBuffer with memory allocated outside of the V8
# sandbox. See https://github.com/chromiumembedded/cef/issues/3332.
'v8_enable_sandbox': False,
# Disable use of //third_party/perfetto for TRACE_EVENT macros. This is
# currently default-enabled on Linux and is causing DCHECK failures.
# See https://github.com/chromiumembedded/cef/issues/3497.
'use_perfetto_client_library': False,
}
if platform == 'windows' or platform == 'mac':