Add option to export tracing events to ETW.

base/trace_event/trace_event_impl.cc

 // Copyright (c) 2012 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.
 
 #include "base/trace_event/trace_event_impl.h"
 
 #include <algorithm>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 #include "base/synchronization/waitable_event.h"
 #include "base/sys_info.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_id_name_manager.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 
 #if defined(OS_WIN)
+#include "base/trace_event/trace_event_etw_export_win.h"
 #include "base/trace_event/trace_event_win.h"
 #endif
 
 class DeleteTraceLogForTesting {
  public:
   static void Delete() {
     Singleton<base::trace_event::TraceLog,
               LeakySingletonTraits<base::trace_event::TraceLog>>::OnExit(0);
   }
 };
@@ skipping 1235 matching lines @@
   const char* category_group = g_category_groups[category_index];
   if (mode_ == RECORDING_MODE &&
       category_filter_.IsCategoryGroupEnabled(category_group))
     enabled_flag |= ENABLED_FOR_RECORDING;
   else if (mode_ == MONITORING_MODE &&
       category_filter_.IsCategoryGroupEnabled(category_group))
     enabled_flag |= ENABLED_FOR_MONITORING;
   if (event_callback_ &&
       event_callback_category_filter_.IsCategoryGroupEnabled(category_group))
     enabled_flag |= ENABLED_FOR_EVENT_CALLBACK;
+#if defined(OS_WIN)
+  if (base::trace_event::TraceEventETWExport::isETWExportEnabled())
+    enabled_flag |= ENABLED_FOR_ETW_EXPORT;
+#endif
+
   g_category_group_enabled[category_index] = enabled_flag;
 }
 
 void TraceLog::UpdateCategoryGroupEnabledFlags() {
   size_t category_index = base::subtle::NoBarrier_Load(&g_category_index);
   for (size_t i = 0; i < category_index; i++)
     UpdateCategoryGroupEnabledFlag(i);
 }
 
 void TraceLog::UpdateSyntheticDelaysFromCategoryFilter() {
@@ skipping 586 matching lines @@
     int num_args,
     const char** arg_names,
     const unsigned char* arg_types,
     const unsigned long long* arg_values,
     const scoped_refptr<ConvertableToTraceFormat>* convertable_values,
     unsigned char flags) {
   TraceEventHandle handle = { 0, 0, 0 };
   if (!*category_group_enabled)
     return handle;
 
+#if defined(OS_WIN)
+  if (*category_group_enabled & ENABLED_FOR_ETW_EXPORT)

[dsinclair, 2015/03/26 18:18:17]

I think this should be down around where the android call is below.   We should
also move this to a method on TraceEvent like Android does with SendToATrace. So
this would have a SendToETW that would be called if needed.

[Georges Khalil, 2015/03/26 23:09:19]

After discussion, brought this down but before the lock gets acquired, as this
is not needed for ETW. It also saves us from creating the event if internal
tracing is not enabled.

+    TraceEventETWExport::AddEvent(phase, category_group_enabled, name, id,
+                                  num_args, arg_names, arg_types, arg_values,
+                                  convertable_values);
+#endif  // OS_WIN
+
   // Avoid re-entrance of AddTraceEvent. This may happen in GPU process when
   // ECHO_TO_CONSOLE is enabled: AddTraceEvent -> LOG(ERROR) ->
   // GpuProcessLogMessageHandler -> PostPendingTask -> TRACE_EVENT ...
   if (thread_is_in_trace_event_.Get())
     return handle;
 
   AutoThreadLocalBoolean thread_is_in_trace_event(&thread_is_in_trace_event_);
 
   DCHECK(name);
   DCHECK(!timestamp.is_null());
@@ skipping 198 matching lines @@
   TraceEventETWProvider::Trace(name, phase, id, extra);
 #endif
   INTERNAL_TRACE_EVENT_ADD(phase, "ETW Trace Event", name,
                            TRACE_EVENT_FLAG_COPY, "id", id, "extra", extra);
 }
 
 void TraceLog::UpdateTraceEventDuration(
     const unsigned char* category_group_enabled,
     const char* name,
     TraceEventHandle handle) {
+#if defined(OS_WIN)
+  if (*category_group_enabled & ENABLED_FOR_ETW_EXPORT)
+    TraceEventETWExport::AddEvent(TRACE_EVENT_PHASE_END, category_group_enabled,

[dsinclair, 2015/03/26 18:18:17]

This isn't what you want here. This is just going to log an end phase, but you
lose the X event. The event is created down around line 2151 which is what needs
to be sent.

(Similar to how the event is SendToATrace())

[Georges Khalil, 2015/03/26 23:09:19]

After review and discussion, this code should be removed for now as there is no
notion of duration in ETW.

+                                  name, 0, 0, NULL, NULL, NULL, NULL);
+#endif  // OS_WIN
+
   // Avoid re-entrance of AddTraceEvent. This may happen in GPU process when
   // ECHO_TO_CONSOLE is enabled: AddTraceEvent -> LOG(ERROR) ->
   // GpuProcessLogMessageHandler -> PostPendingTask -> TRACE_EVENT ...
   if (thread_is_in_trace_event_.Get())
     return;
 
   AutoThreadLocalBoolean thread_is_in_trace_event(&thread_is_in_trace_event_);
 
   TimeTicks thread_now = ThreadNow();
   TimeTicks now = OffsetNow();
@@ skipping 475 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_,
                                                 name_, event_handle_);
   }
 }
 
 }  // namespace trace_event_internal