Update //base to chromium 9659b08ea5a34f889dc4166217f438095ddc10d2

base/trace_event/trace_event_etw_export_win.cc

 // Copyright 2015 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_etw_export_win.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
+#include "base/strings/string_tokenizer.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_impl.h"
 
 // The GetProcAddress technique is borrowed from
 // https://github.com/google/UIforETW/tree/master/ETWProviders
 //
 // EVNTAPI is used in evntprov.h which is included by chrome_events_win.h.
 // We define EVNTAPI without the DECLSPEC_IMPORT specifier so that we can
 // implement these functions locally instead of using the import library, and
@@ skipping 13 matching lines @@
                                          PREGHANDLE RegHandle);
 typedef ULONG(__stdcall* tEventWrite)(REGHANDLE RegHandle,
                                       PCEVENT_DESCRIPTOR EventDescriptor,
                                       ULONG UserDataCount,
                                       PEVENT_DATA_DESCRIPTOR UserData);
 typedef ULONG(__stdcall* tEventUnregister)(REGHANDLE RegHandle);
 
 tEventRegister EventRegisterProc = nullptr;
 tEventWrite EventWriteProc = nullptr;
 tEventUnregister EventUnregisterProc = nullptr;
+
+// |filtered_event_group_names| contains the event categories that can be
+// exported individually. These categories can be enabled by passing the correct
+// keyword when starting the trace. A keyword is a 64-bit flag and we attribute
+// one bit per category. We can therefore enable a particular category by
+// setting its corresponding bit in the keyword. For events that are not present
+// in |filtered_event_group_names|, we have two bits that control their
+// behaviour. When bit 61 is enabled, any event that is not disabled by default
+// (ie. doesn't start with disabled-by-default-) will be exported. Likewise,
+// when bit 62 is enabled, any event that is disabled by default will be
+// exported.
+//
+// Note that bit 63 (MSB) must always be set, otherwise tracing will be disabled
+// by ETW. Therefore, the keyword will always be greater than
+// 0x8000000000000000.
+//
+// Examples of passing keywords to the provider using xperf:
+// # This exports "benchmark" and "cc" events
+// xperf -start chrome -on Chrome:0x8000000000000009
+//
+// # This exports "gpu", "netlog" and all other events that are not disabled by
+// # default
+// xperf -start chrome -on Chrome:0xA0000000000000A0
+//
+// More info about starting a trace and keyword can be obtained by using the
+// help section of xperf (xperf -help start). Note that xperf documentation
+// refers to keywords as flags and there are two ways to enable them, using
+// group names or the hex representation. We only support the latter. Also, we
+// ignore the level.
+const char* const filtered_event_group_names[] = {
+    "benchmark",                                         // 0x1
+    "blink",                                             // 0x2
+    "browser",                                           // 0x4
+    "cc",                                                // 0x8
+    "evdev",                                             // 0x10
+    "gpu",                                               // 0x20
+    "input",                                             // 0x40
+    "netlog",                                            // 0x80
+    "renderer.scheduler",                                // 0x100
+    "toplevel",                                          // 0x200
+    "v8",                                                // 0x400
+    "disabled-by-default-cc.debug",                      // 0x800
+    "disabled-by-default-cc.debug.picture",              // 0x1000
+    "disabled-by-default-toplevel.flow"};                // 0x2000
+const char* other_events_group_name = "__OTHER_EVENTS";  // 0x2000000000000000
+const char* disabled_other_events_group_name =
+    "__DISABLED_OTHER_EVENTS";  // 0x4000000000000000
+uint64 other_events_keyword_bit = 1ULL << 61;
+uint64 disabled_other_events_keyword_bit = 1ULL << 62;
 }  // namespace
 
 // Redirector function for EventRegister. Called by macros in
 // chrome_events_win.h
 ULONG EVNTAPI EventRegister(LPCGUID ProviderId,
                             PENABLECALLBACK EnableCallback,
                             PVOID CallbackContext,
                             PREGHANDLE RegHandle) {
   if (EventRegisterProc)
     return EventRegisterProc(ProviderId, EnableCallback, CallbackContext,
@@ skipping 17 matching lines @@
 // chrome_events_win.h
 ULONG EVNTAPI EventUnregister(REGHANDLE RegHandle) {
   if (EventUnregisterProc)
     return EventUnregisterProc(RegHandle);
   return 0;
 }
 
 namespace base {
 namespace trace_event {
 
-TraceEventETWExport::TraceEventETWExport() : ETWExportEnabled_(false) {
+TraceEventETWExport::TraceEventETWExport()
+    : etw_export_enabled_(false), etw_match_any_keyword_(0ULL) {
   // Find Advapi32.dll. This should always succeed.
   HMODULE AdvapiDLL = ::LoadLibraryW(L"Advapi32.dll");
   if (AdvapiDLL) {
     // Try to find the ETW functions. This will fail on XP.
     EventRegisterProc = reinterpret_cast<tEventRegister>(
         ::GetProcAddress(AdvapiDLL, "EventRegister"));
     EventWriteProc = reinterpret_cast<tEventWrite>(
         ::GetProcAddress(AdvapiDLL, "EventWrite"));
     EventUnregisterProc = reinterpret_cast<tEventUnregister>(
         ::GetProcAddress(AdvapiDLL, "EventUnregister"));
 
     // Register the ETW provider. If registration fails then the event logging
     // calls will fail (on XP this call will do nothing).
     EventRegisterChrome();
+
+    UpdateEnabledCategories();
   }
 }
 
 TraceEventETWExport::~TraceEventETWExport() {
   EventUnregisterChrome();
 }
 
 // static
 TraceEventETWExport* TraceEventETWExport::GetInstance() {
   return Singleton<TraceEventETWExport,
                    StaticMemorySingletonTraits<TraceEventETWExport>>::get();
 }
 
 // static
 void TraceEventETWExport::EnableETWExport() {
   if (GetInstance())
-    GetInstance()->ETWExportEnabled_ = true;
+    GetInstance()->etw_export_enabled_ = true;
 }
 
 // static
 void TraceEventETWExport::DisableETWExport() {
   if (GetInstance())
-    GetInstance()->ETWExportEnabled_ = false;
+    GetInstance()->etw_export_enabled_ = false;
 }
 
 // static
+bool TraceEventETWExport::IsETWExportEnabled() {
+  return (GetInstance() && GetInstance()->etw_export_enabled_);
+}
+
+// static
 void TraceEventETWExport::AddEvent(
     char phase,
     const unsigned char* category_group_enabled,
     const char* name,
     unsigned long long id,
     int num_args,
     const char** arg_names,
     const unsigned char* arg_types,
     const unsigned long long* arg_values,
     const scoped_refptr<ConvertableToTraceFormat>* convertable_values) {
   // We bail early in case exporting is disabled or no consumer is listening.
-  if (!GetInstance() || !GetInstance()->ETWExportEnabled_ ||
+  if (!GetInstance() || !GetInstance()->etw_export_enabled_ ||
       !EventEnabledChromeEvent())
     return;
 
   const char* phase_string = nullptr;
   // Space to store the phase identifier and null-terminator, when needed.
   char phase_buffer[2];
   switch (phase) {
     case TRACE_EVENT_PHASE_BEGIN:
       phase_string = "Begin";
       break;
@@ skipping 61 matching lines @@
       break;
   }
 
   std::string arg_values_string[3];
   for (int i = 0; i < num_args; i++) {
     if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE) {
       // Temporarily do nothing here. This function consumes 1/3 to 1/2 of
       // *total* process CPU time when ETW tracing, and many of the strings
       // created exceed WPA's 4094 byte limit and are shown as:
       // "Unable to parse data". See crbug.com/488257
-      //convertable_values[i]->AppendAsTraceFormat(arg_values_string + i);
+      // convertable_values[i]->AppendAsTraceFormat(arg_values_string + i);
     } else {
       TraceEvent::TraceValue trace_event;
       trace_event.as_uint = arg_values[i];
       TraceEvent::AppendValueAsJSON(arg_types[i], trace_event,
                                     arg_values_string + i);
     }
   }
 
   EventWriteChromeEvent(
       name, phase_string, num_args > 0 ? arg_names[0] : "",
       arg_values_string[0].c_str(), num_args > 1 ? arg_names[1] : "",
       arg_values_string[1].c_str(), num_args > 2 ? arg_names[2] : "",
       arg_values_string[2].c_str());
 }
 
 // static
 void TraceEventETWExport::AddCustomEvent(const char* name,
                                          char const* phase,
                                          const char* arg_name_1,
                                          const char* arg_value_1,
                                          const char* arg_name_2,
                                          const char* arg_value_2,
                                          const char* arg_name_3,
                                          const char* arg_value_3) {
-  if (!GetInstance() || !GetInstance()->ETWExportEnabled_ ||
+  if (!GetInstance() || !GetInstance()->etw_export_enabled_ ||
       !EventEnabledChromeEvent())
     return;
 
   EventWriteChromeEvent(name, phase, arg_name_1, arg_value_1, arg_name_2,
                         arg_value_2, arg_name_3, arg_value_3);
 }
 
-void TraceEventETWExport::Resurrect() {
-  StaticMemorySingletonTraits<TraceEventETWExport>::Resurrect();
+// static
+bool TraceEventETWExport::IsCategoryGroupEnabled(
+    const char* category_group_name) {
+  DCHECK(category_group_name);
+  auto instance = GetInstance();
+  if (instance == nullptr)
+    return false;
+
+  if (!instance->IsETWExportEnabled())
+    return false;
+
+  CStringTokenizer category_group_tokens(
+      category_group_name, category_group_name + strlen(category_group_name),
+      ",");
+  while (category_group_tokens.GetNext()) {
+    std::string category_group_token = category_group_tokens.token();
+    if (instance->IsCategoryEnabled(category_group_token.c_str())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool TraceEventETWExport::UpdateEnabledCategories() {
+  if (etw_match_any_keyword_ == CHROME_Context.MatchAnyKeyword)
+    return false;
+
+  // If the keyword has changed, update each category.
+  // Chrome_Context.MatchAnyKeyword is set by UIforETW (or other ETW trace
+  // recording tools) using the ETW infrastructure. This value will be set in
+  // all Chrome processes that have registered their ETW provider.
+  etw_match_any_keyword_ = CHROME_Context.MatchAnyKeyword;
+  for (int i = 0; i < ARRAYSIZE(filtered_event_group_names); i++) {
+    if (etw_match_any_keyword_ & (1ULL << i)) {
+      categories_status_[filtered_event_group_names[i]] = true;
+    } else {
+      categories_status_[filtered_event_group_names[i]] = false;
+    }
+  }
+
+  // Also update the two default categories.
+  if (etw_match_any_keyword_ & other_events_keyword_bit) {
+    categories_status_[other_events_group_name] = true;
+  } else {
+    categories_status_[other_events_group_name] = false;
+  }
+  if (etw_match_any_keyword_ & disabled_other_events_keyword_bit) {
+    categories_status_[disabled_other_events_group_name] = true;
+  } else {
+    categories_status_[disabled_other_events_group_name] = false;
+  }
+
+  return true;
+}
+
+bool TraceEventETWExport::IsCategoryEnabled(const char* category_name) const {
+  // Try to find the category and return its status if found
+  auto it = categories_status_.find(category_name);
+  if (it != categories_status_.end())
+    return it->second;
+
+  // Otherwise return the corresponding default status by first checking if the
+  // category is disabled by default.
+  if (StringPiece(category_name).starts_with("disabled-by-default")) {
+    DCHECK(categories_status_.find(disabled_other_events_group_name) !=
+           categories_status_.end());
+    return categories_status_.find(disabled_other_events_group_name)->second;
+  } else {
+    DCHECK(categories_status_.find(other_events_group_name) !=
+           categories_status_.end());
+    return categories_status_.find(other_events_group_name)->second;
+  }
 }
 
 }  // namespace trace_event
 }  // namespace base