cef_trace_event
Class CefTraceEndOnScopeClose

class CefTraceEndOnScopeClose

Trace events are for tracking application performance and resource usage. Macros are provided to track: Begin and end of function calls Counters Events are issued against categories. Whereas LOG's categories are statically defined, TRACE categories are created implicitly with a string. For example: TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent") Events can be INSTANT, or can be pairs of BEGIN and END in the same scope: TRACE_EVENT_BEGIN0("MY_SUBSYSTEM", "SomethingCostly") doSomethingCostly() TRACE_EVENT_END0("MY_SUBSYSTEM", "SomethingCostly") Note: Our tools can't always determine the correct BEGIN/END pairs unless these are used in the same scope. Use ASYNC_BEGIN/ASYNC_END macros if you need them to be in separate scopes. A common use case is to trace entire function scopes. This issues a trace BEGIN and END automatically: void doSomethingCostly() { TRACE_EVENT0("MY_SUBSYSTEM", "doSomethingCostly"); ... } Additional parameters can be associated with an event: void doSomethingCostly2(int howMuch) { TRACE_EVENT1("MY_SUBSYSTEM", "doSomethingCostly", "howMuch", howMuch); ... } The trace system will automatically add to this information the current process id, thread id, and a timestamp in microseconds. To trace an asynchronous procedure such as an IPC send/receive, use ASYNC_BEGIN and ASYNC_END: [single threaded sender code] static int send_count = 0; ++send_count; TRACE_EVENT_ASYNC_BEGIN0("ipc", "message", send_count); Send(new MyMessage(send_count)); [receive code] void OnMyMessage(send_count) { TRACE_EVENT_ASYNC_END0("ipc", "message", send_count); } The third parameter is a unique ID to match ASYNC_BEGIN/ASYNC_END pairs. ASYNC_BEGIN and ASYNC_END can occur on any thread of any traced process. Pointers can be used for the ID parameter, and they will be mangled internally so that the same pointer on two different processes will not match. For example: class MyTracedClass { public: MyTracedClass() { TRACE_EVENT_ASYNC_BEGIN0("category", "MyTracedClass", this); } ~MyTracedClass() { TRACE_EVENT_ASYNC_END0("category", "MyTracedClass", this); } } The trace event also supports counters, which is a way to track a quantity as it varies over time. Counters are created with the following macro: TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter", g_myCounterValue); Counters are process-specific. The macro itself can be issued from any thread, however. Sometimes, you want to track two counters at once. You can do this with two counter macros: TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter0", g_myCounterValue[0]); TRACE_COUNTER1("MY_SUBSYSTEM", "myCounter1", g_myCounterValue[1]); Or you can do it with a combined macro: TRACE_COUNTER2("MY_SUBSYSTEM", "myCounter", "bytesPinned", g_myCounterValue[0], "bytesAllocated", g_myCounterValue[1]); This indicates to the tracing UI that these counters should be displayed in a single graph, as a summed area chart. Since counters are in a global namespace, you may want to disembiguate with a unique ID, by using the TRACE_COUNTER_ID* variations. By default, trace collection is compiled in, but turned off at runtime. Collecting trace data is the responsibility of the embedding application. In CEF's case, calling BeginTracing will turn on tracing on all active processes. Memory scoping note: Tracing copies the pointers, not the string content, of the strings passed in for category, name, and arg_names. Thus, the following code will cause problems: char* str = strdup("impprtantName"); TRACE_EVENT_INSTANT0("SUBSYSTEM", str); // BAD! free(str); // Trace system now has dangling pointer 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.

CefTraceEndOnScopeClose

public CefTraceEndOnScopeClose( const char* category, const char* name );

~CefTraceEndOnScopeClose

public ~CefTraceEndOnScopeClose();