| // Copyright 2015 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <memory> |
| |
| #include "base/base_paths.h" |
| #include "base/json/json_reader.h" |
| #include "base/json/json_writer.h" |
| #include "base/path_service.h" |
| #include "base/run_loop.h" |
| #include "base/system/sys_info.h" |
| #include "base/test/bind.h" |
| #include "base/test/test_proto_loader.h" |
| #include "base/time/time.h" |
| #include "base/values.h" |
| #include "build/build_config.h" |
| #include "content/browser/tracing/background_tracing_config_impl.h" |
| #include "content/browser/tracing/background_tracing_rule.h" |
| #include "content/public/test/browser_task_environment.h" |
| #include "net/base/network_change_notifier.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/abseil-cpp/absl/types/optional.h" |
| #include "third_party/perfetto/protos/perfetto/config/chrome/scenario_config.gen.h" |
| |
| namespace content { |
| |
| namespace { |
| |
| class MockNetworkChangeNotifier : public net::NetworkChangeNotifier { |
| public: |
| ConnectionType GetCurrentConnectionType() const override { return type_; } |
| void set_type(ConnectionType type) { type_ = type; } |
| |
| private: |
| ConnectionType type_; |
| }; |
| |
| base::FilePath GetTestDataRoot() { |
| return base::PathService::CheckedGet(base::DIR_GEN_TEST_DATA_ROOT); |
| } |
| |
| void CreateRuleConfig(const std::string& proto_text, |
| perfetto::protos::gen::TriggerRule& destination) { |
| base::TestProtoLoader loader; |
| std::string serialized_message; |
| loader.ParseFromText(GetTestDataRoot().Append(FILE_PATH_LITERAL( |
| "third_party/perfetto/protos/perfetto/" |
| "config/chrome/scenario_config.descriptor")), |
| "perfetto.protos.TriggerRule", proto_text, |
| serialized_message); |
| ASSERT_TRUE(destination.ParseFromString(serialized_message)); |
| } |
| |
| } // namespace |
| |
| class BackgroundTracingConfigTest : public testing::Test { |
| public: |
| BackgroundTracingConfigTest() = default; |
| |
| protected: |
| BrowserTaskEnvironment task_environment_{ |
| base::test::TaskEnvironment::TimeSource::MOCK_TIME}; |
| }; |
| |
| std::unique_ptr<BackgroundTracingConfigImpl> ReadFromJSONString( |
| const std::string& json_text) { |
| absl::optional<base::Value> json_value(base::JSONReader::Read(json_text)); |
| |
| if (!json_value || !json_value->is_dict()) |
| return nullptr; |
| |
| std::unique_ptr<BackgroundTracingConfigImpl> config( |
| static_cast<BackgroundTracingConfigImpl*>( |
| BackgroundTracingConfig::FromDict(std::move(*json_value).TakeDict()) |
| .release())); |
| return config; |
| } |
| |
| std::string ConfigToString(BackgroundTracingConfig* config) { |
| std::string results; |
| if (base::JSONWriter::Write(config->ToDict(), &results)) |
| return results; |
| return ""; |
| } |
| |
| std::string RuleToString(const std::unique_ptr<BackgroundTracingRule>& rule) { |
| std::string results; |
| if (base::JSONWriter::Write(rule->ToDict(), &results)) |
| return results; |
| return ""; |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, ConfigFromInvalidString) { |
| // Missing or invalid mode |
| EXPECT_FALSE(ReadFromJSONString("{}")); |
| EXPECT_FALSE(ReadFromJSONString("{\"mode\":\"invalid\"}")); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, PreemptiveConfigFromInvalidString) { |
| // Missing or invalid category |
| EXPECT_FALSE(ReadFromJSONString("{\"mode\":\"preemptive\"}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"preemptive\", \"category\": \"invalid\"}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| "\"invalid\",\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"trigger_name\":\"foo\"}]}")); |
| |
| // Missing rules. |
| EXPECT_FALSE( |
| ReadFromJSONString("{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| "\"BENCHMARK_STARTUP\",\"configs\": []}")); |
| |
| // Missing or invalid configs |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"preemptive\", \"category\": \"benchmark\"}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| "\"configs\": \"\"}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| "\"configs\": {}}")); |
| |
| // Invalid config entries |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| "\"configs\": [{}]}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| "\"configs\": [\"invalid\"]}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| "\"configs\": [[]]}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| "\"configs\": [{\"rule\": \"invalid\"}]}")); |
| |
| // Missing or invalid keys for a named trigger. |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| "\"configs\": [{\"rule\": \"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\"}]}")); |
| |
| // Missing or invalid keys for a histogram trigger. |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| "\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\", " |
| "\"histogram_name\":\"foo\"}]}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| "\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\", " |
| "\"histogram_lower_value\": 1, \"histogram_upper_value\": 2}]}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| "\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\", " |
| "\"histogram_name\":\"foo\", \"histogram_lower_value\": 1," |
| "\"histogram_upper_value\": 1}]}")); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, ReactiveConfigFromInvalidString) { |
| // Missing or invalid configs |
| EXPECT_FALSE(ReadFromJSONString("{\"mode\":\"reactive\"}")); |
| EXPECT_FALSE( |
| ReadFromJSONString("{\"mode\":\"reactive\", \"configs\": \"invalid\"}")); |
| EXPECT_FALSE(ReadFromJSONString("{\"mode\":\"reactive\", \"configs\": {}}")); |
| |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"REACTIVE_TRACING_MODE\", \"configs\": []}")); |
| |
| // Invalid config entries |
| EXPECT_FALSE( |
| ReadFromJSONString("{\"mode\":\"reactive\", \"configs\": [{}]}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"reactive\", \"configs\": [\"invalid\"]}")); |
| |
| // Invalid tracing rule type |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"reactive\"," |
| "\"configs\": [{\"rule\": []}]}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"reactive\"," |
| "\"configs\": [{\"rule\": \"\"}]}")); |
| EXPECT_FALSE( |
| ReadFromJSONString("{\"mode\":\"reactive\"," |
| "\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\"}]}")); |
| |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"reactive\"," |
| "\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"category\": " |
| "[]}]}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"reactive\"," |
| "\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"category\": " |
| "\"\"}]}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"reactive\"," |
| "\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"category\": " |
| "\"benchmark\"}]}")); |
| |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"reactive\"," |
| "\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"category\": " |
| "\"benchmark\", \"trigger_name\": []}]}")); |
| EXPECT_FALSE(ReadFromJSONString( |
| "{\"mode\":\"reactive\"," |
| "\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"category\": " |
| "\"benchmark\", \"trigger_name\": 0}]}")); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, PreemptiveConfigFromValidString) { |
| std::unique_ptr<BackgroundTracingConfigImpl> config; |
| |
| config = ReadFromJSONString( |
| "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| "\"BENCHMARK_STARTUP\",\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"trigger_name\":\"foo\"}]}"); |
| EXPECT_TRUE(config); |
| EXPECT_EQ(config->tracing_mode(), BackgroundTracingConfig::PREEMPTIVE); |
| EXPECT_EQ(config->category_preset(), |
| BackgroundTracingConfigImpl::BENCHMARK_STARTUP); |
| EXPECT_EQ(config->rules().size(), 1u); |
| EXPECT_EQ(RuleToString(config->rules()[0]), |
| "{\"rule\":\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\"," |
| "\"trigger_name\":\"foo\"}"); |
| |
| config = ReadFromJSONString( |
| "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| "\"BENCHMARK_STARTUP\",\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\", " |
| "\"histogram_name\":\"foo\", \"histogram_value\": 1}]}"); |
| EXPECT_TRUE(config); |
| EXPECT_EQ(config->tracing_mode(), BackgroundTracingConfig::PREEMPTIVE); |
| EXPECT_EQ(config->category_preset(), |
| BackgroundTracingConfigImpl::BENCHMARK_STARTUP); |
| EXPECT_EQ(config->rules().size(), 1u); |
| EXPECT_EQ(RuleToString(config->rules()[0]), |
| "{\"histogram_lower_value\":1,\"histogram_name\":\"foo\"," |
| "\"histogram_upper_value\":2147483647," |
| "\"rule\":\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\"}"); |
| |
| config = ReadFromJSONString( |
| "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| "\"BENCHMARK_STARTUP\",\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\", " |
| "\"histogram_name\":\"foo\", \"histogram_value\": 1}]}"); |
| EXPECT_TRUE(config); |
| EXPECT_EQ(config->tracing_mode(), BackgroundTracingConfig::PREEMPTIVE); |
| EXPECT_EQ(config->category_preset(), |
| BackgroundTracingConfigImpl::BENCHMARK_STARTUP); |
| EXPECT_EQ(config->rules().size(), 1u); |
| EXPECT_EQ(RuleToString(config->rules()[0]), |
| "{\"histogram_lower_value\":1,\"histogram_name\":\"foo\"," |
| "\"histogram_upper_value\":2147483647," |
| "\"rule\":\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\"}"); |
| |
| config = ReadFromJSONString( |
| "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| "\"BENCHMARK_STARTUP\",\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\", " |
| "\"histogram_name\":\"foo\", \"histogram_lower_value\": 1, " |
| "\"histogram_upper_value\": 2}]}"); |
| EXPECT_TRUE(config); |
| EXPECT_EQ(config->tracing_mode(), BackgroundTracingConfig::PREEMPTIVE); |
| EXPECT_EQ(config->category_preset(), |
| BackgroundTracingConfigImpl::BENCHMARK_STARTUP); |
| EXPECT_EQ(config->rules().size(), 1u); |
| EXPECT_EQ(RuleToString(config->rules()[0]), |
| "{\"histogram_lower_value\":1,\"histogram_name\":\"foo\"," |
| "\"histogram_upper_value\":2,\"rule\":" |
| "\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\"}"); |
| |
| config = ReadFromJSONString( |
| "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| "\"BENCHMARK_STARTUP\",\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\", " |
| "\"histogram_name\":\"foo\", \"histogram_lower_value\": 1, " |
| "\"histogram_upper_value\": 2}]}"); |
| EXPECT_TRUE(config); |
| EXPECT_EQ(config->tracing_mode(), BackgroundTracingConfig::PREEMPTIVE); |
| EXPECT_EQ(config->category_preset(), |
| BackgroundTracingConfigImpl::BENCHMARK_STARTUP); |
| EXPECT_EQ(config->rules().size(), 1u); |
| EXPECT_EQ(RuleToString(config->rules()[0]), |
| "{\"histogram_lower_value\":1,\"histogram_name\":\"foo\"," |
| "\"histogram_upper_value\":2,\"rule\":" |
| "\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\"}"); |
| |
| config = ReadFromJSONString( |
| "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| "\"BENCHMARK_STARTUP\",\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\", " |
| "\"histogram_name\":\"foo\", \"histogram_value\": 1}]}"); |
| EXPECT_TRUE(config); |
| EXPECT_EQ(config->tracing_mode(), BackgroundTracingConfig::PREEMPTIVE); |
| EXPECT_EQ(config->category_preset(), |
| BackgroundTracingConfigImpl::BENCHMARK_STARTUP); |
| EXPECT_EQ(config->rules().size(), 1u); |
| EXPECT_EQ(RuleToString(config->rules()[0]), |
| "{\"histogram_lower_value\":1,\"histogram_name\":\"foo\"," |
| "\"histogram_upper_value\":2147483647," |
| "\"rule\":\"MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE\"}"); |
| |
| config = ReadFromJSONString( |
| "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| "\"BENCHMARK_STARTUP\",\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"trigger_name\":\"foo1\"}, " |
| "{\"rule\": \"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", " |
| "\"trigger_name\":\"foo2\"}]}"); |
| EXPECT_TRUE(config); |
| EXPECT_EQ(config->tracing_mode(), BackgroundTracingConfig::PREEMPTIVE); |
| EXPECT_EQ(config->category_preset(), |
| BackgroundTracingConfigImpl::BENCHMARK_STARTUP); |
| EXPECT_EQ(config->rules().size(), 2u); |
| EXPECT_EQ(RuleToString(config->rules()[0]), |
| "{\"rule\":\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\"," |
| "\"trigger_name\":\"foo1\"}"); |
| EXPECT_EQ(RuleToString(config->rules()[1]), |
| "{\"rule\":\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\"," |
| "\"trigger_name\":\"foo2\"}"); |
| |
| config = ReadFromJSONString( |
| "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"custom_categories\": " |
| "\"toplevel,benchmark\",\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"trigger_name\":\"foo1\"}]}"); |
| EXPECT_TRUE(config); |
| EXPECT_EQ(config->tracing_mode(), BackgroundTracingConfig::PREEMPTIVE); |
| EXPECT_EQ(config->category_preset(), |
| BackgroundTracingConfigImpl::CUSTOM_CATEGORY_PRESET); |
| EXPECT_EQ(config->rules().size(), 1u); |
| EXPECT_EQ( |
| ConfigToString(config.get()), |
| "{\"category\":\"CUSTOM\",\"configs\":[{\"rule\":\"MONITOR_AND_DUMP_WHEN_" |
| "TRIGGER_NAMED\",\"trigger_name\":\"foo1\"}],\"custom_categories\":" |
| "\"toplevel,benchmark\",\"mode\":\"PREEMPTIVE_TRACING_MODE\"}"); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, ValidPreemptiveCategoryToString) { |
| std::unique_ptr<BackgroundTracingConfigImpl> config = ReadFromJSONString( |
| "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| "\"BENCHMARK_STARTUP\",\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"trigger_name\":\"foo\"}]}"); |
| |
| constexpr BackgroundTracingConfigImpl::CategoryPreset kCategoryPreset = |
| BackgroundTracingConfigImpl::BENCHMARK_STARTUP; |
| constexpr const char kCategoryString[] = "BENCHMARK_STARTUP"; |
| |
| config->set_category_preset(kCategoryPreset); |
| std::string expected = |
| std::string("{\"category\":\"") + kCategoryString + |
| std::string( |
| "\",\"configs\":[{\"rule\":" |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\",\"trigger_name\":" |
| "\"foo\"}],\"mode\":\"PREEMPTIVE_TRACING_MODE\"}"); |
| EXPECT_EQ(ConfigToString(config.get()), expected.c_str()); |
| std::unique_ptr<BackgroundTracingConfigImpl> config2 = |
| ReadFromJSONString(expected); |
| EXPECT_EQ(config->category_preset(), config2->category_preset()); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, ReactiveConfigFromValidString) { |
| std::unique_ptr<BackgroundTracingConfigImpl> config; |
| |
| config = ReadFromJSONString( |
| "{\"mode\":\"REACTIVE_TRACING_MODE\",\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", " |
| "\"trigger_delay\":30," |
| "\"trigger_name\": \"foo\"}]}"); |
| EXPECT_TRUE(config); |
| EXPECT_EQ(config->tracing_mode(), BackgroundTracingConfig::REACTIVE); |
| EXPECT_EQ(config->rules().size(), 1u); |
| EXPECT_EQ(RuleToString(config->rules()[0]), |
| "{\"rule\":\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\"," |
| "\"trigger_delay\":30,\"trigger_name\":\"foo\"}"); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, ValidPreemptiveConfigToString) { |
| std::unique_ptr<BackgroundTracingConfigImpl> config( |
| new BackgroundTracingConfigImpl(BackgroundTracingConfig::PREEMPTIVE)); |
| |
| // Default values |
| EXPECT_EQ(ConfigToString(config.get()), |
| "{\"category\":\"BENCHMARK_STARTUP\",\"configs\":[],\"mode\":" |
| "\"PREEMPTIVE_" |
| "TRACING_MODE\"}"); |
| |
| // Change category_preset |
| config->set_category_preset(BackgroundTracingConfigImpl::BENCHMARK_STARTUP); |
| EXPECT_EQ(ConfigToString(config.get()), |
| "{\"category\":\"BENCHMARK_STARTUP\",\"configs\":[],\"mode\":" |
| "\"PREEMPTIVE_TRACING_MODE\"}"); |
| |
| { |
| config = std::make_unique<BackgroundTracingConfigImpl>( |
| BackgroundTracingConfig::PREEMPTIVE); |
| config->set_category_preset(BackgroundTracingConfigImpl::BENCHMARK_STARTUP); |
| |
| base::Value::Dict dict; |
| dict.Set("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED"); |
| dict.Set("trigger_name", "foo"); |
| config->AddPreemptiveRule(dict); |
| |
| EXPECT_EQ(ConfigToString(config.get()), |
| "{\"category\":\"BENCHMARK_STARTUP\",\"configs\":[{\"rule\":" |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\",\"trigger_name\":" |
| "\"foo\"}],\"mode\":\"PREEMPTIVE_TRACING_MODE\"}"); |
| } |
| |
| { |
| config = std::make_unique<BackgroundTracingConfigImpl>( |
| BackgroundTracingConfig::PREEMPTIVE); |
| config->set_category_preset(BackgroundTracingConfigImpl::BENCHMARK_STARTUP); |
| |
| base::Value::Dict dict; |
| dict.Set("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED"); |
| dict.Set("trigger_name", "foo"); |
| dict.Set("trigger_chance", 0.5); |
| config->AddPreemptiveRule(dict); |
| |
| EXPECT_EQ( |
| ConfigToString(config.get()), |
| "{\"category\":\"BENCHMARK_STARTUP\",\"configs\":[{\"rule\":" |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\",\"trigger_chance\":0.5," |
| "\"trigger_name\":\"foo\"}],\"mode\":\"PREEMPTIVE_TRACING_MODE\"}"); |
| } |
| |
| { |
| config = std::make_unique<BackgroundTracingConfigImpl>( |
| BackgroundTracingConfig::PREEMPTIVE); |
| config->set_category_preset(BackgroundTracingConfigImpl::BENCHMARK_STARTUP); |
| |
| base::Value::Dict dict; |
| dict.Set("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED"); |
| dict.Set("trigger_name", "foo1"); |
| config->AddPreemptiveRule(dict); |
| |
| dict.Set("trigger_name", "foo2"); |
| config->AddPreemptiveRule(dict); |
| |
| EXPECT_EQ(ConfigToString(config.get()), |
| "{\"category\":\"BENCHMARK_STARTUP\",\"configs\":[{\"rule\":" |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\",\"trigger_name\":" |
| "\"foo1\"},{\"rule\":\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\"," |
| "\"trigger_name\":\"foo2\"}],\"mode\":\"PREEMPTIVE_TRACING_" |
| "MODE\"}"); |
| } |
| |
| { |
| config = std::make_unique<BackgroundTracingConfigImpl>( |
| BackgroundTracingConfig::PREEMPTIVE); |
| |
| base::Value::Dict second_dict; |
| second_dict.Set("rule", |
| "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE"); |
| second_dict.Set("histogram_name", "foo"); |
| second_dict.Set("histogram_lower_value", 1); |
| second_dict.Set("histogram_upper_value", 2); |
| config->AddPreemptiveRule(second_dict); |
| |
| EXPECT_EQ( |
| ConfigToString(config.get()), |
| "{\"category\":\"BENCHMARK_STARTUP\",\"configs\":[{\"histogram_lower_" |
| "value\":1,\"histogram_name\":\"foo\"," |
| "\"histogram_upper_value\":2,\"rule\":\"MONITOR_AND_DUMP_WHEN_" |
| "SPECIFIC_HISTOGRAM_AND_VALUE\"}],\"mode\":\"PREEMPTIVE_TRACING_" |
| "MODE\"}"); |
| } |
| |
| { |
| config = std::make_unique<BackgroundTracingConfigImpl>( |
| BackgroundTracingConfig::PREEMPTIVE); |
| |
| base::Value::Dict second_dict; |
| second_dict.Set("rule", |
| "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE"); |
| second_dict.Set("histogram_name", "foo"); |
| second_dict.Set("histogram_lower_value", 1); |
| second_dict.Set("histogram_upper_value", 2); |
| second_dict.Set("trigger_delay", 10); |
| config->AddPreemptiveRule(second_dict); |
| |
| EXPECT_EQ( |
| ConfigToString(config.get()), |
| "{\"category\":\"BENCHMARK_STARTUP\",\"configs\":[{\"histogram_lower_" |
| "value\":1,\"histogram_name\":\"foo\"," |
| "\"histogram_upper_value\":2,\"rule\":\"MONITOR_AND_DUMP_WHEN_" |
| "SPECIFIC_HISTOGRAM_AND_VALUE\",\"trigger_delay\":10}],\"mode\":" |
| "\"PREEMPTIVE_TRACING_MODE\"}"); |
| } |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, InvalidPreemptiveConfigToString) { |
| std::unique_ptr<BackgroundTracingConfigImpl> config; |
| |
| { |
| config = std::make_unique<BackgroundTracingConfigImpl>( |
| BackgroundTracingConfig::PREEMPTIVE); |
| |
| base::Value::Dict dict; |
| dict.Set("rule", "MONITOR_AND_DUMP_WHEN_BROWSER_STARTUP_COMPLETE"); |
| config->AddPreemptiveRule(dict); |
| |
| EXPECT_EQ(ConfigToString(config.get()), |
| "{\"category\":\"BENCHMARK_STARTUP\",\"configs\":[],\"mode\":" |
| "\"PREEMPTIVE_TRACING_MODE\"}"); |
| } |
| |
| { |
| config = std::make_unique<BackgroundTracingConfigImpl>( |
| BackgroundTracingConfig::PREEMPTIVE); |
| |
| // TODO(crbug.com/1247459): |second_dict| is not used. |
| base::Value::Dict second_dict; |
| second_dict.Set("rule", |
| "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE"); |
| second_dict.Set("histogram_name", "foo"); |
| second_dict.Set("histogram_lower_value", 1); |
| |
| EXPECT_EQ(ConfigToString(config.get()), |
| "{\"category\":\"BENCHMARK_STARTUP\",\"configs\":[],\"mode\":" |
| "\"PREEMPTIVE_TRACING_MODE\"}"); |
| } |
| |
| { |
| config = std::make_unique<BackgroundTracingConfigImpl>( |
| BackgroundTracingConfig::PREEMPTIVE); |
| |
| // TODO(crbug.com/1247459): |second_dict| is not used. |
| base::Value::Dict second_dict; |
| second_dict.Set("rule", |
| "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE"); |
| second_dict.Set("histogram_name", "foo"); |
| second_dict.Set("histogram_lower_value", 1); |
| second_dict.Set("histogram_upper_value", 1); |
| |
| EXPECT_EQ(ConfigToString(config.get()), |
| "{\"category\":\"BENCHMARK_STARTUP\",\"configs\":[],\"mode\":" |
| "\"PREEMPTIVE_TRACING_MODE\"}"); |
| } |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, ValidReactiveConfigToString) { |
| std::unique_ptr<BackgroundTracingConfigImpl> config( |
| new BackgroundTracingConfigImpl(BackgroundTracingConfig::REACTIVE)); |
| |
| // Default values |
| EXPECT_EQ(ConfigToString(config.get()), |
| "{\"configs\":[],\"mode\":\"REACTIVE_TRACING_MODE\"}"); |
| |
| { |
| config = std::make_unique<BackgroundTracingConfigImpl>( |
| BackgroundTracingConfig::REACTIVE); |
| |
| base::Value::Dict dict; |
| dict.Set("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED"); |
| dict.Set("trigger_name", "foo"); |
| config->AddReactiveRule(dict); |
| |
| EXPECT_EQ(ConfigToString(config.get()), |
| "{\"configs\":[{\"rule\":\"" |
| "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\"," |
| "\"trigger_name\":\"foo\"}],\"mode\":\"REACTIVE_TRACING_MODE\"}"); |
| } |
| |
| { |
| config = std::make_unique<BackgroundTracingConfigImpl>( |
| BackgroundTracingConfig::REACTIVE); |
| |
| base::Value::Dict dict; |
| dict.Set("rule", "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED"); |
| dict.Set("trigger_name", "foo1"); |
| config->AddReactiveRule(dict); |
| |
| dict.Set("trigger_name", "foo2"); |
| config->AddReactiveRule(dict); |
| |
| EXPECT_EQ( |
| ConfigToString(config.get()), |
| "{\"configs\":[{\"rule\":" |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\"," |
| "\"trigger_name\":\"foo1\"},{" |
| "\"rule\":\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\"," |
| "\"trigger_name\":\"foo2\"}],\"mode\":\"REACTIVE_TRACING_MODE\"}"); |
| } |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, BufferLimitConfig) { |
| MockNetworkChangeNotifier notifier; |
| |
| std::unique_ptr<BackgroundTracingConfigImpl> config; |
| |
| config = ReadFromJSONString( |
| "{\"mode\":\"REACTIVE_TRACING_MODE\",\"configs\": [{\"rule\": " |
| "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", " |
| "\"category\": \"BENCHMARK_STARTUP\",\"trigger_delay\":30," |
| "\"trigger_name\": \"foo\"}],\"low_ram_buffer_size_kb\":800," |
| "\"medium_ram_buffer_size_kb\":1000,\"mobile_network_buffer_size_kb\":" |
| "300,\"max_buffer_size_kb\":1000,\"upload_limit_kb\":500," |
| "\"upload_limit_network_kb\":600}"); |
| EXPECT_TRUE(config); |
| EXPECT_EQ(config->tracing_mode(), BackgroundTracingConfig::REACTIVE); |
| EXPECT_EQ(config->rules().size(), 1u); |
| |
| notifier.set_type(net::NetworkChangeNotifier::CONNECTION_2G); |
| #if BUILDFLAG(IS_ANDROID) |
| int64_t ram_mb = base::SysInfo::AmountOfPhysicalMemoryMB(); |
| size_t expected_trace_buffer_size = |
| (ram_mb > 0 && ram_mb <= 1024) ? 800u : 300u; |
| EXPECT_EQ(expected_trace_buffer_size, |
| config->GetTraceConfig().GetTraceBufferSizeInKb()); |
| EXPECT_EQ(600u, config->GetTraceUploadLimitKb()); |
| #endif |
| |
| notifier.set_type(net::NetworkChangeNotifier::CONNECTION_WIFI); |
| EXPECT_LE(800u, config->GetTraceConfig().GetTraceBufferSizeInKb()); |
| EXPECT_EQ(500u, config->GetTraceUploadLimitKb()); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, HistogramRuleFromValidProto) { |
| perfetto::protos::gen::TriggerRule config; |
| CreateRuleConfig( |
| R"pb( |
| name: "test_rule" |
| trigger_chance: 0.5 |
| delay_ms: 500 |
| histogram: { histogram_name: "foo" min_value: 1 max_value: 2 } |
| )pb", |
| config); |
| auto rule = BackgroundTracingRule::Create(config); |
| auto result = rule->ToProtoForTesting(); |
| EXPECT_EQ("test_rule", result.name()); |
| EXPECT_EQ(0.5, result.trigger_chance()); |
| EXPECT_EQ(500U, result.delay_ms()); |
| EXPECT_TRUE(result.has_histogram()); |
| EXPECT_EQ("foo", result.histogram().histogram_name()); |
| EXPECT_EQ(1, result.histogram().min_value()); |
| EXPECT_EQ(2, result.histogram().max_value()); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, NamedRuleFromValidProto) { |
| perfetto::protos::gen::TriggerRule config; |
| CreateRuleConfig(R"pb( |
| name: "test_rule" |
| trigger_chance: 0.5 |
| delay_ms: 500 |
| manual_trigger_name: "test_trigger" |
| )pb", |
| config); |
| auto rule = BackgroundTracingRule::Create(config); |
| auto result = rule->ToProtoForTesting(); |
| EXPECT_EQ("test_rule", result.name()); |
| EXPECT_EQ(0.5, result.trigger_chance()); |
| EXPECT_EQ(500U, result.delay_ms()); |
| EXPECT_EQ("test_trigger", result.manual_trigger_name()); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, TimerRuleFromValidProto) { |
| perfetto::protos::gen::TriggerRule config; |
| CreateRuleConfig(R"pb( |
| name: "test_rule" trigger_chance: 0.5 delay_ms: 500 |
| )pb", |
| config); |
| auto rule = BackgroundTracingRule::Create(config); |
| auto result = rule->ToProtoForTesting(); |
| EXPECT_EQ("test_rule", result.name()); |
| EXPECT_EQ(0.5, result.trigger_chance()); |
| EXPECT_EQ(500U, result.delay_ms()); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, TimerRuleTriggersAfterDelay) { |
| perfetto::protos::gen::TriggerRule config; |
| CreateRuleConfig(R"pb( |
| name: "test_rule" delay_ms: 10000 |
| )pb", |
| config); |
| |
| base::TimeTicks start = base::TimeTicks::Now(); |
| auto rule = BackgroundTracingRule::Create(config); |
| base::RunLoop run_loop; |
| rule->Install(base::BindLambdaForTesting([&](const BackgroundTracingRule*) { |
| run_loop.Quit(); |
| return true; |
| })); |
| run_loop.Run(); |
| DCHECK_GE(base::TimeTicks::Now(), start + base::Milliseconds(10000)); |
| rule->Uninstall(); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, RepeatingIntervalRuleFromValidProto) { |
| perfetto::protos::gen::TriggerRule config; |
| CreateRuleConfig( |
| R"pb( |
| name: "test_rule" |
| trigger_chance: 0.5 |
| delay_ms: 500 |
| repeating_interval: { period_ms: 1000 randomized: true } |
| )pb", |
| config); |
| auto rule = BackgroundTracingRule::Create(config); |
| auto result = rule->ToProtoForTesting(); |
| EXPECT_EQ("test_rule", result.name()); |
| EXPECT_EQ(0.5, result.trigger_chance()); |
| EXPECT_EQ(500U, result.delay_ms()); |
| EXPECT_TRUE(result.has_repeating_interval()); |
| EXPECT_EQ(1000U, result.repeating_interval().period_ms()); |
| EXPECT_TRUE(result.repeating_interval().randomized()); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, RepeatingIntervalRuleTriggersAfterDelay) { |
| perfetto::protos::gen::TriggerRule config; |
| CreateRuleConfig(R"pb( |
| name: "test_rule" |
| repeating_interval: { period_ms: 2000 } |
| )pb", |
| config); |
| |
| base::TimeTicks start = base::TimeTicks::Now(); |
| auto rule = BackgroundTracingRule::Create(config); |
| std::vector<base::TimeTicks> trigger_times; |
| auto callback = base::BindLambdaForTesting([&](const BackgroundTracingRule*) { |
| trigger_times.push_back(base::TimeTicks::Now()); |
| return true; |
| }); |
| rule->Install(callback); |
| task_environment_.FastForwardBy(base::Seconds(2)); // Triggers at 2s |
| rule->Uninstall(); |
| task_environment_.FastForwardBy(base::Seconds(1)); |
| rule->Install(callback); |
| task_environment_.FastForwardBy(base::Seconds(2)); // Triggers at 4s |
| rule->Uninstall(); |
| task_environment_.FastForwardBy(base::Seconds(2)); // Skips 6s |
| rule->Install(callback); |
| task_environment_.FastForwardBy(base::Seconds(1)); // Triggers at 8s |
| |
| EXPECT_EQ(std::vector<base::TimeTicks>({ |
| start + base::Seconds(2), |
| start + base::Seconds(4), |
| start + base::Seconds(8), |
| }), |
| trigger_times); |
| rule->Uninstall(); |
| } |
| |
| TEST_F(BackgroundTracingConfigTest, RepeatingIntervalRuleTriggersRandomized) { |
| perfetto::protos::gen::TriggerRule config; |
| CreateRuleConfig( |
| R"pb( |
| name: "test_rule" |
| repeating_interval: { period_ms: 2000 randomized: true } |
| )pb", |
| config); |
| |
| base::TimeTicks start = base::TimeTicks::Now(); |
| auto rule = BackgroundTracingRule::Create(config); |
| std::vector<base::TimeTicks> trigger_times; |
| auto callback = base::BindLambdaForTesting([&](const BackgroundTracingRule*) { |
| trigger_times.push_back(base::TimeTicks::Now()); |
| return true; |
| }); |
| rule->Install(callback); |
| task_environment_.FastForwardBy(base::Seconds(4)); // Triggers twice |
| ASSERT_EQ(2U, trigger_times.size()); |
| EXPECT_GE(trigger_times[0], start); |
| EXPECT_LT(trigger_times[0], trigger_times[1]); |
| EXPECT_GE(trigger_times[1], start + base::Seconds(2)); |
| rule->Uninstall(); |
| } |
| |
| } // namespace content |
