[ETW Export] Add polling for ETW keyword.

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"
@@ skipping 72 matching lines @@
     "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;
+
+// Time between checks for ETW keyword changes (in milliseconds).
+unsigned int kUpdateTimerDelayMs = 1000;
 }  // 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 61 matching lines @@
     GetInstance()->etw_export_enabled_ = true;
 }
 
 // static
 void TraceEventETWExport::DisableETWExport() {
   if (GetInstance())
     GetInstance()->etw_export_enabled_ = false;
 }
 
 // static
+bool TraceEventETWExport::IsETWExportEnabled() {
+  return (GetInstance() && GetInstance()->etw_export_enabled_);

[brucedawson, 2015/06/26 22:24:24]

If you move this and change it in the same CL then the change is very hard to
see. Consider leaving it in its original location.

A separate CL to move it (before or after) would also work.

+}
+
+// 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) {
@@ skipping 106 matching lines @@
                                          const char* arg_name_3,
                                          const char* arg_value_3) {
   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;
 }
 
-void TraceEventETWExport::UpdateEnabledCategories() {
+// static
+void TraceEventETWExport::StartKeywordUpdateTimer() {
+  if (IsETWExportEnabled()) {
+    GetInstance()->keyword_update_timer_.Start(
+        FROM_HERE, base::TimeDelta::FromMilliseconds(kUpdateTimerDelayMs),
+        base::Bind(&TraceEventETWExport::KeywordUpdateTimerCallback));
+  }
+}
+
+void TraceEventETWExport::Resurrect() {
+  StaticMemorySingletonTraits<TraceEventETWExport>::Resurrect();
+}
+
+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.
-  if (etw_match_any_keyword_ != CHROME_Context.MatchAnyKeyword) {
-    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;
-      }
+  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;
   }
 }
 
+// static
+void TraceEventETWExport::KeywordUpdateTimerCallback() {
+  DCHECK(GetInstance());
+  if (IsETWExportEnabled()) {
+    if (GetInstance()->UpdateEnabledCategories())
+      TraceLog::GetInstance()->UpdateCategoryGroupEnabledFlags();
+  }
+}
 }  // namespace trace_event
 }  // namespace base