tracing: split trace event filter classes out of TraceLog

base/trace_event/trace_event_unittest.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.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 12 matching lines @@
 #include "base/memory/singleton.h"
 #include "base/process/process_handle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/pattern.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
+#include "base/trace_event/event_name_filter.h"
+#include "base/trace_event/heap_profiler_event_filter.h"
 #include "base/trace_event/trace_buffer.h"
 #include "base/trace_event/trace_event.h"
+#include "base/trace_event/trace_event_filter.h"
+#include "base/trace_event/trace_event_filter_test_utils.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "base/values.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
@@ skipping 2904 matching lines @@
   config1.Merge(config2);
   EXPECT_EQ(2u, config1.GetSyntheticDelayValues().size());
 }
 
 TEST_F(TraceEventTestFixture, SyntheticDelayConfigurationToString) {
   const char filter[] = "DELAY(test.Delay;16;oneshot)";
   TraceConfig config(filter, "");
   EXPECT_EQ(filter, config.ToCategoryFilterString());
 }
 
-class TestEventFilter : public TraceLog::TraceEventFilter {
- public:
-  bool FilterTraceEvent(const TraceEvent& trace_event) const override {
-    filter_trace_event_hit_count_++;
-    return filter_return_value_;
-  }
-
-  void EndEvent(const char* category_group, const char* name) override {
-    end_event_hit_count_++;
-  }
-
-  static void set_filter_return_value(bool value) {
-    filter_return_value_ = value;
-  }
-
-  static size_t filter_trace_event_hit_count() {
-    return filter_trace_event_hit_count_;
-  }
-  static size_t end_event_hit_count() { return end_event_hit_count_; }
-
-  static void clear_counts() {
-    filter_trace_event_hit_count_ = 0;
-    end_event_hit_count_ = 0;
-  }
-
- private:
-  static size_t filter_trace_event_hit_count_;
-  static size_t end_event_hit_count_;
-  static bool filter_return_value_;
-};
-
-size_t TestEventFilter::filter_trace_event_hit_count_ = 0;
-size_t TestEventFilter::end_event_hit_count_ = 0;
-bool TestEventFilter::filter_return_value_ = false;
-
-std::unique_ptr<TraceLog::TraceEventFilter> ConstructTestEventFilter() {
-  return WrapUnique(new TestEventFilter);
-}
-
 TEST_F(TraceEventTestFixture, TraceFilteringMode) {
   const char config_json[] =
       "{"
       "  \"event_filters\": ["
       "     {"
       "       \"filter_predicate\": \"testing_predicate\", "
       "       \"included_categories\": [\"*\"]"
       "     }"
       "  ]"
       "}";
 
   // Run RECORDING_MODE within FILTERING_MODE:
+  TestEventFilter::HitsCounter filter_hits_counter;
   TestEventFilter::set_filter_return_value(true);
-  TraceLog::SetTraceEventFilterConstructorForTesting(ConstructTestEventFilter);
+  TraceLog::GetInstance()->SetFilterFactoryForTesting(TestEventFilter::Factory);
 
   // Only filtering mode is enabled with test filters.
   TraceLog::GetInstance()->SetEnabled(TraceConfig(config_json),
                                       TraceLog::FILTERING_MODE);
   EXPECT_EQ(TraceLog::FILTERING_MODE, TraceLog::GetInstance()->enabled_modes());
   {
     void* ptr = this;
     TRACE_EVENT0("c0", "name0");
     TRACE_EVENT_ASYNC_BEGIN0("c1", "name1", ptr);
     TRACE_EVENT_INSTANT0("c0", "name0", TRACE_EVENT_SCOPE_THREAD);
@@ skipping 19 matching lines @@
   TraceLog::GetInstance()->SetDisabled(TraceLog::FILTERING_MODE);
   EXPECT_EQ(0, TraceLog::GetInstance()->enabled_modes());
 
   EndTraceAndFlush();
   EXPECT_FALSE(FindMatchingValue("cat", "c0"));
   EXPECT_FALSE(FindMatchingValue("cat", "c1"));
   EXPECT_FALSE(FindMatchingValue("name", "name0"));
   EXPECT_FALSE(FindMatchingValue("name", "name1"));
   EXPECT_TRUE(FindMatchingValue("cat", "c2"));
   EXPECT_TRUE(FindMatchingValue("name", "name2"));
-  EXPECT_EQ(6u, TestEventFilter::filter_trace_event_hit_count());
-  EXPECT_EQ(3u, TestEventFilter::end_event_hit_count());
+  EXPECT_EQ(6u, filter_hits_counter.filter_trace_event_hit_count);
+  EXPECT_EQ(3u, filter_hits_counter.end_event_hit_count);
   Clear();
-  TestEventFilter::clear_counts();
+  filter_hits_counter.Reset();
 
   // Run FILTERING_MODE within RECORDING_MODE:
   // Only recording mode is enabled and all events must be recorded.
   TraceLog::GetInstance()->SetEnabled(TraceConfig("", ""),
                                       TraceLog::RECORDING_MODE);
   EXPECT_EQ(TraceLog::RECORDING_MODE, TraceLog::GetInstance()->enabled_modes());
   {
     TRACE_EVENT0("c0", "name0");
   }
 
@@ skipping 18 matching lines @@
   TraceLog::GetInstance()->SetDisabled(TraceLog::RECORDING_MODE);
   EXPECT_EQ(0, TraceLog::GetInstance()->enabled_modes());
 
   EndTraceAndFlush();
   EXPECT_TRUE(FindMatchingValue("cat", "c0"));
   EXPECT_TRUE(FindMatchingValue("cat", "c2"));
   EXPECT_TRUE(FindMatchingValue("name", "name0"));
   EXPECT_TRUE(FindMatchingValue("name", "name2"));
   EXPECT_FALSE(FindMatchingValue("cat", "c1"));
   EXPECT_FALSE(FindMatchingValue("name", "name1"));
-  EXPECT_EQ(1u, TestEventFilter::filter_trace_event_hit_count());
-  EXPECT_EQ(1u, TestEventFilter::end_event_hit_count());
+  EXPECT_EQ(1u, filter_hits_counter.filter_trace_event_hit_count);
+  EXPECT_EQ(1u, filter_hits_counter.end_event_hit_count);
   Clear();
-  TestEventFilter::clear_counts();
 }
 
 TEST_F(TraceEventTestFixture, EventFiltering) {
   const char config_json[] =
       "{"
       "  \"included_categories\": ["
       "    \"filtered_cat\","
       "    \"unfiltered_cat\"],"
       "  \"event_filters\": ["
       "     {"
       "       \"filter_predicate\": \"testing_predicate\", "
       "       \"included_categories\": [\"filtered_cat\"]"
       "     }"
       "    "
       "  ]"
       "}";
 
+  TestEventFilter::HitsCounter filter_hits_counter;
   TestEventFilter::set_filter_return_value(true);
-  TraceLog::SetTraceEventFilterConstructorForTesting(ConstructTestEventFilter);
+  TraceLog::GetInstance()->SetFilterFactoryForTesting(TestEventFilter::Factory);
+
   TraceConfig trace_config(config_json);
   TraceLog::GetInstance()->SetEnabled(
       trace_config, TraceLog::RECORDING_MODE | TraceLog::FILTERING_MODE);
   ASSERT_TRUE(TraceLog::GetInstance()->IsEnabled());
 
   TRACE_EVENT0("filtered_cat", "a snake");
   TRACE_EVENT0("filtered_cat", "a mushroom");
   TRACE_EVENT0("unfiltered_cat", "a horse");
 
   // This is scoped so we can test the end event being filtered.
   { TRACE_EVENT0("filtered_cat", "another cat whoa"); }
 
   EndTraceAndFlush();
 
-  EXPECT_EQ(3u, TestEventFilter::filter_trace_event_hit_count());
-  EXPECT_EQ(1u, TestEventFilter::end_event_hit_count());
-  TestEventFilter::clear_counts();
+  EXPECT_EQ(3u, filter_hits_counter.filter_trace_event_hit_count);
+  EXPECT_EQ(1u, filter_hits_counter.end_event_hit_count);
 }
 
 TEST_F(TraceEventTestFixture, EventWhitelistFiltering) {
   std::string config_json = StringPrintf(
       "{"
       "  \"included_categories\": ["
       "    \"filtered_cat\","
       "    \"unfiltered_cat\"],"
       "  \"event_filters\": ["
       "     {"
       "       \"filter_predicate\": \"%s\", "
       "       \"included_categories\": [\"*\"], "
       "       \"excluded_categories\": [\"unfiltered_cat\"], "
       "       \"filter_args\": {"
       "           \"event_name_whitelist\": [\"a snake\", \"a dog\"]"
       "         }"
       "     }"
       "    "
       "  ]"
       "}",
-      TraceLog::TraceEventFilter::kEventWhitelistPredicate);
+      EventNameFilter::kName);
 
   TraceConfig trace_config(config_json);
   TraceLog::GetInstance()->SetEnabled(
       trace_config, TraceLog::RECORDING_MODE | TraceLog::FILTERING_MODE);
   EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
 
   TRACE_EVENT0("filtered_cat", "a snake");
   TRACE_EVENT0("filtered_cat", "a mushroom");
   TRACE_EVENT0("unfiltered_cat", "a cat");
 
@@ skipping 11 matching lines @@
       "    \"filtered_cat\","
       "    \"unfiltered_cat\"],"
       "  \"excluded_categories\": [\"excluded_cat\"],"
       "  \"event_filters\": ["
       "     {"
       "       \"filter_predicate\": \"%s\", "
       "       \"included_categories\": [\"*\"]"
       "     }"
       "  ]"
       "}",
-      TraceLog::TraceEventFilter::kHeapProfilerPredicate);
+      HeapProfilerEventFilter::kName);
 
   TraceConfig trace_config(config_json);
   TraceLog::GetInstance()->SetEnabled(
       trace_config, TraceLog::RECORDING_MODE | TraceLog::FILTERING_MODE);
   EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
 
   TRACE_EVENT0("filtered_cat", "a snake");
   TRACE_EVENT0("excluded_cat", "a mushroom");
   TRACE_EVENT0("unfiltered_cat", "a cat");
 
   EndTraceAndFlush();
 
   // The predicate should not change behavior of the trace events.
   EXPECT_TRUE(FindMatchingValue("name", "a snake"));
   EXPECT_FALSE(FindMatchingValue("name", "a mushroom"));
   EXPECT_TRUE(FindMatchingValue("name", "a cat"));
 }
 
 TEST_F(TraceEventTestFixture, ClockSyncEventsAreAlwaysAddedToTrace) {
   BeginSpecificTrace("-*");
   TRACE_EVENT_CLOCK_SYNC_RECEIVER(1);
   EndTraceAndFlush();
   EXPECT_TRUE(FindNamePhase("clock_sync", "c"));
 }
 
 }  // namespace trace_event
 }  // namespace base