[tracing] Use same code path for category filtering for recording and event filtering

base/trace_event/trace_config_unittest.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 <stddef.h>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/trace_event/memory_dump_manager.h"
@@ skipping 286 matching lines @@
   TraceConfig tc_asterisk("*", "");
 
   EXPECT_STREQ("", tc_empty.ToCategoryFilterString().c_str());
   EXPECT_STREQ("*", tc_asterisk.ToCategoryFilterString().c_str());
 
   // Both fall back to default config.
   CheckDefaultTraceConfigBehavior(tc_empty);
   CheckDefaultTraceConfigBehavior(tc_asterisk);
 
   // They differ only for internal checking.
-  EXPECT_FALSE(tc_empty.IsCategoryEnabled("Category1"));
-  EXPECT_FALSE(tc_empty.IsCategoryEnabled("not-excluded-category"));
-  EXPECT_TRUE(tc_asterisk.IsCategoryEnabled("Category1"));
-  EXPECT_TRUE(tc_asterisk.IsCategoryEnabled("not-excluded-category"));
+  EXPECT_FALSE(tc_empty.category_filter().IsCategoryEnabled("Category1"));
+  EXPECT_FALSE(
+      tc_empty.category_filter().IsCategoryEnabled("not-excluded-category"));
+  EXPECT_TRUE(tc_asterisk.category_filter().IsCategoryEnabled("Category1"));
+  EXPECT_TRUE(
+      tc_asterisk.category_filter().IsCategoryEnabled("not-excluded-category"));
 }
 
 TEST(TraceConfigTest, DisabledByDefaultCategoryFilterString) {
   TraceConfig tc("foo,disabled-by-default-foo", "");
   EXPECT_STREQ("foo,disabled-by-default-foo",
                tc.ToCategoryFilterString().c_str());
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("foo"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-foo"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("bar"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("disabled-by-default-bar"));
@@ skipping 74 matching lines @@
   TraceConfig tc(config_string);
 
   EXPECT_STREQ(config_string, tc.ToString().c_str());
   EXPECT_EQ(RECORD_CONTINUOUSLY, tc.GetTraceRecordMode());
   EXPECT_TRUE(tc.IsSystraceEnabled());
   EXPECT_TRUE(tc.IsArgumentFilterEnabled());
   EXPECT_STREQ("included,inc_pattern*,disabled-by-default-cc,-excluded,"
                "-exc_pattern*,DELAY(test.Delay1;16),DELAY(test.Delay2;32)",
                tc.ToCategoryFilterString().c_str());
 
-  EXPECT_TRUE(tc.IsCategoryEnabled("included"));
-  EXPECT_TRUE(tc.IsCategoryEnabled("inc_pattern_category"));
-  EXPECT_TRUE(tc.IsCategoryEnabled("disabled-by-default-cc"));
-  EXPECT_FALSE(tc.IsCategoryEnabled("excluded"));
-  EXPECT_FALSE(tc.IsCategoryEnabled("exc_pattern_category"));
-  EXPECT_FALSE(tc.IsCategoryEnabled("disabled-by-default-others"));
-  EXPECT_FALSE(tc.IsCategoryEnabled("not-excluded-nor-included"));
+  EXPECT_TRUE(tc.category_filter().IsCategoryEnabled("included"));
+  EXPECT_TRUE(tc.category_filter().IsCategoryEnabled("inc_pattern_category"));
+  EXPECT_TRUE(tc.category_filter().IsCategoryEnabled("disabled-by-default-cc"));
+  EXPECT_FALSE(tc.category_filter().IsCategoryEnabled("excluded"));
+  EXPECT_FALSE(tc.category_filter().IsCategoryEnabled("exc_pattern_category"));
+  EXPECT_FALSE(
+      tc.category_filter().IsCategoryEnabled("disabled-by-default-others"));
+  EXPECT_FALSE(
+      tc.category_filter().IsCategoryEnabled("not-excluded-nor-included"));
 
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("included"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("inc_pattern_category"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-cc"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("exc_pattern_category"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("disabled-by-default-others"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("not-excluded-nor-included"));
 
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("included,excluded"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded,exc_pattern_category"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("included,DELAY(test.Delay1;16)"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("DELAY(test.Delay1;16)"));
 
   EXPECT_EQ(2u, tc.GetSyntheticDelayValues().size());
   EXPECT_STREQ("test.Delay1;16", tc.GetSyntheticDelayValues()[0].c_str());
   EXPECT_STREQ("test.Delay2;32", tc.GetSyntheticDelayValues()[1].c_str());
 
   EXPECT_EQ(tc.event_filters().size(), 1u);
   const TraceConfig::EventFilterConfig& event_filter = tc.event_filters()[0];
   EXPECT_STREQ("event_whitelist_predicate",
                event_filter.predicate_name().c_str());
-  EXPECT_EQ(1u, event_filter.included_categories().size());
-  EXPECT_STREQ("*", event_filter.included_categories()[0].c_str());
-  EXPECT_EQ(1u, event_filter.excluded_categories().size());
-  EXPECT_STREQ("unfiltered_cat", event_filter.excluded_categories()[0].c_str());
+  EXPECT_EQ(1u, event_filter.category_filter().included_categories().size());
+  EXPECT_STREQ("*",
+               event_filter.category_filter().included_categories()[0].c_str());
+  EXPECT_EQ(1u, event_filter.category_filter().excluded_categories().size());
+  EXPECT_STREQ("unfiltered_cat",
+               event_filter.category_filter().excluded_categories()[0].c_str());
   EXPECT_TRUE(event_filter.filter_args());
 
   std::string json_out;
   base::JSONWriter::Write(*event_filter.filter_args(), &json_out);
   EXPECT_STREQ(json_out.c_str(),
                "{\"event_name_whitelist\":[\"a snake\",\"a dog\"]}");
   std::unordered_set<std::string> filter_values;
   EXPECT_TRUE(event_filter.GetArgAsSet("event_name_whitelist", &filter_values));
   EXPECT_EQ(2u, filter_values.size());
   EXPECT_EQ(1u, filter_values.count("a snake"));
   EXPECT_EQ(1u, filter_values.count("a dog"));
 
   const char config_string_2[] = "{\"included_categories\":[\"*\"]}";
   TraceConfig tc2(config_string_2);
-  EXPECT_TRUE(tc2.IsCategoryEnabled("non-disabled-by-default-pattern"));
-  EXPECT_FALSE(tc2.IsCategoryEnabled("disabled-by-default-pattern"));
+  EXPECT_TRUE(tc2.category_filter().IsCategoryEnabled(
+      "non-disabled-by-default-pattern"));
+  EXPECT_FALSE(
+      tc2.category_filter().IsCategoryEnabled("disabled-by-default-pattern"));
   EXPECT_TRUE(tc2.IsCategoryGroupEnabled("non-disabled-by-default-pattern"));
   EXPECT_FALSE(tc2.IsCategoryGroupEnabled("disabled-by-default-pattern"));
 
   // Clear
   tc.Clear();
   EXPECT_STREQ(tc.ToString().c_str(),
                "{"
                  "\"enable_argument_filter\":false,"
                  "\"enable_systrace\":false,"
                  "\"record_mode\":\"record-until-full\""
@@ skipping 67 matching lines @@
   EXPECT_FALSE(tc.IsArgumentFilterEnabled());
   EXPECT_STREQ("-excluded,DELAY(test.Delay1;16),DELAY(test.Delay2;32)",
                tc.ToCategoryFilterString().c_str());
 
   const char invalid_config_string_2[] =
     "{"
       "\"included_categories\":[\"category\",\"disabled-by-default-pattern\"],"
       "\"excluded_categories\":[\"category\",\"disabled-by-default-pattern\"]"
     "}";
   tc = TraceConfig(invalid_config_string_2);
-  EXPECT_TRUE(tc.IsCategoryEnabled("category"));
-  EXPECT_TRUE(tc.IsCategoryEnabled("disabled-by-default-pattern"));
+  EXPECT_TRUE(tc.category_filter().IsCategoryEnabled("category"));
+  EXPECT_TRUE(
+      tc.category_filter().IsCategoryEnabled("disabled-by-default-pattern"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("category"));
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("disabled-by-default-pattern"));
 }
 
 TEST(TraceConfigTest, MergingTraceConfigs) {
   // Merge
   TraceConfig tc;
   TraceConfig tc2("included,-excluded,inc_pattern*,-exc_pattern*", "");
   tc.Merge(tc2);
   EXPECT_STREQ("{"
@@ skipping 31 matching lines @@
   EXPECT_TRUE(tc.IsCategoryGroupEnabled("included"));
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("other_included"));
 
   // Excluding categories won't enable disabled-by-default ones with the
   // excluded category is also present in the group.
   tc = TraceConfig("-excluded", "");
   EXPECT_STREQ("-excluded", tc.ToCategoryFilterString().c_str());
   EXPECT_FALSE(tc.IsCategoryGroupEnabled("excluded,disabled-by-default-cc"));
 }
 
-TEST(TraceConfigTest, IsEmptyOrContainsLeadingOrTrailingWhitespace) {
-  // Test that IsEmptyOrContainsLeadingOrTrailingWhitespace actually catches
-  // categories that are explicitly forbidden.
-  // This method is called in a DCHECK to assert that we don't have these types
-  // of strings as categories.
-  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
-      " bad_category "));
-  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
-      " bad_category"));
-  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
-      "bad_category "));
-  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
-      "   bad_category"));
-  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
-      "bad_category   "));
-  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
-      "   bad_category   "));
-  EXPECT_TRUE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
-      ""));
-  EXPECT_FALSE(TraceConfig::IsEmptyOrContainsLeadingOrTrailingWhitespace(
-      "good_category"));
+TEST(TraceConfigTest, IsCategoryNameAllowed) {
+  // Test that IsCategoryNameAllowed actually catches categories that are
+  // explicitly forbidden. This method is called in a DCHECK to assert that we
+  // don't have these types of strings as categories.
+  EXPECT_FALSE(
+      TraceConfigCategoryFilter::IsCategoryNameAllowed(" bad_category "));
+  EXPECT_FALSE(
+      TraceConfigCategoryFilter::IsCategoryNameAllowed(" bad_category"));
+  EXPECT_FALSE(
+      TraceConfigCategoryFilter::IsCategoryNameAllowed("bad_category "));
+  EXPECT_FALSE(
+      TraceConfigCategoryFilter::IsCategoryNameAllowed("   bad_category"));
+  EXPECT_FALSE(
+      TraceConfigCategoryFilter::IsCategoryNameAllowed("bad_category   "));
+  EXPECT_FALSE(
+      TraceConfigCategoryFilter::IsCategoryNameAllowed("   bad_category   "));
+  EXPECT_FALSE(TraceConfigCategoryFilter::IsCategoryNameAllowed(""));
+  EXPECT_TRUE(
+      TraceConfigCategoryFilter::IsCategoryNameAllowed("good_category"));
 }
 
 TEST(TraceConfigTest, SetTraceOptionValues) {
   TraceConfig tc;
   EXPECT_EQ(RECORD_UNTIL_FULL, tc.GetTraceRecordMode());
   EXPECT_FALSE(tc.IsSystraceEnabled());
 
   tc.SetTraceRecordMode(RECORD_AS_MUCH_AS_POSSIBLE);
   EXPECT_EQ(RECORD_AS_MUCH_AS_POSSIBLE, tc.GetTraceRecordMode());
 
   tc.EnableSystrace();
   EXPECT_TRUE(tc.IsSystraceEnabled());
 }
 
 TEST(TraceConfigTest, TraceConfigFromMemoryConfigString) {
   std::string tc_str1 =
       TraceConfigMemoryTestUtil::GetTraceConfig_PeriodicTriggers(200, 2000);
   TraceConfig tc1(tc_str1);
   EXPECT_EQ(tc_str1, tc1.ToString());
   TraceConfig tc2(
       TraceConfigMemoryTestUtil::GetTraceConfig_LegacyPeriodicTriggers(200,
                                                                        2000));
   EXPECT_EQ(tc_str1, tc2.ToString());
 
   EXPECT_TRUE(tc1.IsCategoryGroupEnabled(MemoryDumpManager::kTraceCategory));
-  ASSERT_EQ(2u, tc1.memory_dump_config_.triggers.size());
+  ASSERT_EQ(2u, tc1.memory_dump_config().triggers.size());
 
   EXPECT_EQ(200u,
-            tc1.memory_dump_config_.triggers[0].min_time_between_dumps_ms);
+            tc1.memory_dump_config().triggers[0].min_time_between_dumps_ms);
   EXPECT_EQ(MemoryDumpLevelOfDetail::LIGHT,
-            tc1.memory_dump_config_.triggers[0].level_of_detail);
+            tc1.memory_dump_config().triggers[0].level_of_detail);
 
   EXPECT_EQ(2000u,
-            tc1.memory_dump_config_.triggers[1].min_time_between_dumps_ms);
+            tc1.memory_dump_config().triggers[1].min_time_between_dumps_ms);
   EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED,
-            tc1.memory_dump_config_.triggers[1].level_of_detail);
+            tc1.memory_dump_config().triggers[1].level_of_detail);
   EXPECT_EQ(
       2048u,
-      tc1.memory_dump_config_.heap_profiler_options.breakdown_threshold_bytes);
+      tc1.memory_dump_config().heap_profiler_options.breakdown_threshold_bytes);
 
   std::string tc_str3 =
       TraceConfigMemoryTestUtil::GetTraceConfig_BackgroundTrigger(
           1 /* period_ms */);
   TraceConfig tc3(tc_str3);
   EXPECT_EQ(tc_str3, tc3.ToString());
   EXPECT_TRUE(tc3.IsCategoryGroupEnabled(MemoryDumpManager::kTraceCategory));
-  ASSERT_EQ(1u, tc3.memory_dump_config_.triggers.size());
-  EXPECT_EQ(1u, tc3.memory_dump_config_.triggers[0].min_time_between_dumps_ms);
+  ASSERT_EQ(1u, tc3.memory_dump_config().triggers.size());
+  EXPECT_EQ(1u, tc3.memory_dump_config().triggers[0].min_time_between_dumps_ms);
   EXPECT_EQ(MemoryDumpLevelOfDetail::BACKGROUND,
-            tc3.memory_dump_config_.triggers[0].level_of_detail);
+            tc3.memory_dump_config().triggers[0].level_of_detail);
 
   std::string tc_str4 =
       TraceConfigMemoryTestUtil::GetTraceConfig_PeakDetectionTrigger(
           1 /*heavy_period */);
   TraceConfig tc4(tc_str4);
   EXPECT_EQ(tc_str4, tc4.ToString());
-  ASSERT_EQ(1u, tc4.memory_dump_config_.triggers.size());
-  EXPECT_EQ(1u, tc4.memory_dump_config_.triggers[0].min_time_between_dumps_ms);
+  ASSERT_EQ(1u, tc4.memory_dump_config().triggers.size());
+  EXPECT_EQ(1u, tc4.memory_dump_config().triggers[0].min_time_between_dumps_ms);
   EXPECT_EQ(MemoryDumpLevelOfDetail::DETAILED,
-            tc4.memory_dump_config_.triggers[0].level_of_detail);
+            tc4.memory_dump_config().triggers[0].level_of_detail);
 }
 
 TEST(TraceConfigTest, EmptyMemoryDumpConfigTest) {
   // Empty trigger list should also be specified when converting back to string.
   TraceConfig tc(TraceConfigMemoryTestUtil::GetTraceConfig_EmptyTriggers());
   EXPECT_EQ(TraceConfigMemoryTestUtil::GetTraceConfig_EmptyTriggers(),
             tc.ToString());
-  EXPECT_EQ(0u, tc.memory_dump_config_.triggers.size());
-  EXPECT_EQ(TraceConfig::MemoryDumpConfig::HeapProfiler
-            ::kDefaultBreakdownThresholdBytes,
-            tc.memory_dump_config_.heap_profiler_options
-            .breakdown_threshold_bytes);
+  EXPECT_EQ(0u, tc.memory_dump_config().triggers.size());
+  EXPECT_EQ(
+      TraceConfig::MemoryDumpConfig::HeapProfiler ::
+          kDefaultBreakdownThresholdBytes,
+      tc.memory_dump_config().heap_profiler_options.breakdown_threshold_bytes);
 }
 
 TEST(TraceConfigTest, LegacyStringToMemoryDumpConfig) {
   TraceConfig tc(MemoryDumpManager::kTraceCategory, "");
   EXPECT_TRUE(tc.IsCategoryGroupEnabled(MemoryDumpManager::kTraceCategory));
   EXPECT_NE(std::string::npos, tc.ToString().find("memory_dump_config"));
-  EXPECT_EQ(2u, tc.memory_dump_config_.triggers.size());
-  EXPECT_EQ(TraceConfig::MemoryDumpConfig::HeapProfiler
-            ::kDefaultBreakdownThresholdBytes,
-            tc.memory_dump_config_.heap_profiler_options
-            .breakdown_threshold_bytes);
+  EXPECT_EQ(2u, tc.memory_dump_config().triggers.size());
+  EXPECT_EQ(
+      TraceConfig::MemoryDumpConfig::HeapProfiler ::
+          kDefaultBreakdownThresholdBytes,
+      tc.memory_dump_config().heap_profiler_options.breakdown_threshold_bytes);
 }
 
 }  // namespace trace_event
 }  // namespace base