| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "base/json/json_reader.h" |
| 6 #include "base/json/json_writer.h" |
| 7 #include "base/memory/scoped_ptr.h" |
| 8 #include "base/values.h" |
| 9 #include "content/public/browser/background_tracing_preemptive_config.h" |
| 10 #include "content/public/browser/background_tracing_reactive_config.h" |
| 11 #include "testing/gtest/include/gtest/gtest.h" |
| 12 |
| 13 namespace content { |
| 14 |
| 15 class BackgroundTracingConfigTest : public testing::Test {}; |
| 16 |
| 17 scoped_ptr<BackgroundTracingConfig> ReadFromJSONString( |
| 18 const std::string& json_text) { |
| 19 scoped_ptr<base::Value> json_value(base::JSONReader::Read(json_text)); |
| 20 |
| 21 base::DictionaryValue* dict = NULL; |
| 22 if (json_value) |
| 23 json_value->GetAsDictionary(&dict); |
| 24 |
| 25 return content::BackgroundTracingConfig::FromDict(dict); |
| 26 } |
| 27 |
| 28 scoped_ptr<BackgroundTracingPreemptiveConfig> ReadPreemptiveFromJSONString( |
| 29 const std::string& json_text) { |
| 30 return make_scoped_ptr(static_cast<BackgroundTracingPreemptiveConfig*>( |
| 31 ReadFromJSONString(json_text).release())); |
| 32 } |
| 33 |
| 34 scoped_ptr<BackgroundTracingReactiveConfig> ReadReactiveFromJSONString( |
| 35 const std::string& json_text) { |
| 36 return make_scoped_ptr(static_cast<BackgroundTracingReactiveConfig*>( |
| 37 ReadFromJSONString(json_text).release())); |
| 38 } |
| 39 |
| 40 std::string ConfigToString(const BackgroundTracingConfig* config) { |
| 41 scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue()); |
| 42 |
| 43 BackgroundTracingConfig::IntoDict(config, dict.get()); |
| 44 |
| 45 std::string results; |
| 46 if (base::JSONWriter::Write(*dict.get(), &results)) |
| 47 return results; |
| 48 return ""; |
| 49 } |
| 50 |
| 51 TEST_F(BackgroundTracingConfigTest, ConfigFromInvalidString) { |
| 52 // Missing or invalid mode |
| 53 EXPECT_FALSE(ReadFromJSONString("{}")); |
| 54 EXPECT_FALSE(ReadFromJSONString("{\"mode\":\"invalid\"}")); |
| 55 } |
| 56 |
| 57 TEST_F(BackgroundTracingConfigTest, PreemptiveConfigFromInvalidString) { |
| 58 // Missing or invalid category |
| 59 EXPECT_FALSE(ReadFromJSONString("{\"mode\":\"preemptive\"}")); |
| 60 EXPECT_FALSE(ReadFromJSONString( |
| 61 "{\"mode\":\"preemptive\", \"category\": \"invalid\"}")); |
| 62 |
| 63 // Missing or invalid configs |
| 64 EXPECT_FALSE(ReadFromJSONString( |
| 65 "{\"mode\":\"preemptive\", \"category\": \"benchmark\"}")); |
| 66 EXPECT_FALSE(ReadFromJSONString( |
| 67 "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| 68 "\"configs\": \"\"}")); |
| 69 EXPECT_FALSE(ReadFromJSONString( |
| 70 "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| 71 "\"configs\": {}}")); |
| 72 |
| 73 // Invalid config entries |
| 74 EXPECT_FALSE(ReadFromJSONString( |
| 75 "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| 76 "\"configs\": [{}]}")); |
| 77 EXPECT_FALSE(ReadFromJSONString( |
| 78 "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| 79 "\"configs\": [\"invalid\"]}")); |
| 80 EXPECT_FALSE(ReadFromJSONString( |
| 81 "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| 82 "\"configs\": [[]]}")); |
| 83 EXPECT_FALSE(ReadFromJSONString( |
| 84 "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| 85 "\"configs\": [{\"rule\": \"invalid\"}]}")); |
| 86 |
| 87 // Missing or invalid keys for a named trigger. |
| 88 EXPECT_FALSE(ReadFromJSONString( |
| 89 "{\"mode\":\"preemptive\", \"category\": \"benchmark\"," |
| 90 "\"configs\": [{\"rule\": \"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\"}]}")); |
| 91 } |
| 92 |
| 93 TEST_F(BackgroundTracingConfigTest, ReactiveConfigFromInvalidString) { |
| 94 // Missing or invalid configs |
| 95 EXPECT_FALSE(ReadFromJSONString("{\"mode\":\"reactive\"}")); |
| 96 EXPECT_FALSE( |
| 97 ReadFromJSONString("{\"mode\":\"reactive\", \"configs\": \"invalid\"}")); |
| 98 EXPECT_FALSE(ReadFromJSONString("{\"mode\":\"reactive\", \"configs\": {}}")); |
| 99 |
| 100 // Invalid config entries |
| 101 EXPECT_FALSE( |
| 102 ReadFromJSONString("{\"mode\":\"reactive\", \"configs\": [{}]}")); |
| 103 EXPECT_FALSE(ReadFromJSONString( |
| 104 "{\"mode\":\"reactive\", \"configs\": [\"invalid\"]}")); |
| 105 |
| 106 // Invalid tracing rule type |
| 107 EXPECT_FALSE(ReadFromJSONString( |
| 108 "{\"mode\":\"reactive\"," |
| 109 "\"configs\": [{\"rule\": []}]}")); |
| 110 EXPECT_FALSE(ReadFromJSONString( |
| 111 "{\"mode\":\"reactive\"," |
| 112 "\"configs\": [{\"rule\": \"\"}]}")); |
| 113 EXPECT_FALSE(ReadFromJSONString( |
| 114 "{\"mode\":\"reactive\"," |
| 115 "\"configs\": [{\"rule\": " |
| 116 "\"trace_on_trigger_until_10s_or_trigger_or_full\"}]}")); |
| 117 |
| 118 EXPECT_FALSE(ReadFromJSONString( |
| 119 "{\"mode\":\"reactive\"," |
| 120 "\"configs\": [{\"rule\": " |
| 121 "\"trace_on_trigger_until_10s_or_trigger_or_full\", \"category\": " |
| 122 "[]}]}")); |
| 123 EXPECT_FALSE(ReadFromJSONString( |
| 124 "{\"mode\":\"reactive\"," |
| 125 "\"configs\": [{\"rule\": " |
| 126 "\"trace_on_trigger_until_10s_or_trigger_or_full\", \"category\": " |
| 127 "\"\"}]}")); |
| 128 EXPECT_FALSE(ReadFromJSONString( |
| 129 "{\"mode\":\"reactive\"," |
| 130 "\"configs\": [{\"rule\": " |
| 131 "\"trace_on_trigger_until_10s_or_trigger_or_full\", \"category\": " |
| 132 "\"benchmark\"}]}")); |
| 133 |
| 134 EXPECT_FALSE(ReadFromJSONString( |
| 135 "{\"mode\":\"reactive\"," |
| 136 "\"configs\": [{\"rule\": " |
| 137 "\"trace_on_trigger_until_10s_or_trigger_or_full\", \"category\": " |
| 138 "\"benchmark\", \"trigger_name\": []}]}")); |
| 139 EXPECT_FALSE(ReadFromJSONString( |
| 140 "{\"mode\":\"reactive\"," |
| 141 "\"configs\": [{\"rule\": " |
| 142 "\"trace_on_trigger_until_10s_or_trigger_or_full\", \"category\": " |
| 143 "\"benchmark\", \"trigger_name\": 0}]}")); |
| 144 } |
| 145 |
| 146 TEST_F(BackgroundTracingConfigTest, PreemptiveConfigFromValidString) { |
| 147 scoped_ptr<BackgroundTracingPreemptiveConfig> config; |
| 148 |
| 149 config = ReadPreemptiveFromJSONString( |
| 150 "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| 151 "\"BENCHMARK\",\"configs\": []}"); |
| 152 EXPECT_TRUE(config); |
| 153 EXPECT_EQ(config->mode, BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE); |
| 154 EXPECT_EQ(config->category_preset, BackgroundTracingConfig::BENCHMARK); |
| 155 EXPECT_EQ(config->configs.size(), 0u); |
| 156 |
| 157 config = ReadPreemptiveFromJSONString( |
| 158 "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| 159 "\"BENCHMARK_DEEP\",\"configs\": []}"); |
| 160 EXPECT_TRUE(config); |
| 161 EXPECT_EQ(config->mode, BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE); |
| 162 EXPECT_EQ(config->category_preset, BackgroundTracingConfig::BENCHMARK_DEEP); |
| 163 EXPECT_EQ(config->configs.size(), 0u); |
| 164 |
| 165 config = ReadPreemptiveFromJSONString( |
| 166 "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| 167 "\"BENCHMARK\",\"configs\": [{\"rule\": " |
| 168 "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"trigger_name\":\"foo\"}]}"); |
| 169 EXPECT_TRUE(config); |
| 170 EXPECT_EQ(config->mode, BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE); |
| 171 EXPECT_EQ(config->category_preset, BackgroundTracingConfig::BENCHMARK); |
| 172 EXPECT_EQ(config->configs.size(), 1u); |
| 173 EXPECT_EQ( |
| 174 config->configs[0].type, |
| 175 BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED); |
| 176 EXPECT_EQ(config->configs[0].named_trigger_info.trigger_name, "foo"); |
| 177 |
| 178 config = ReadPreemptiveFromJSONString( |
| 179 "{\"mode\":\"PREEMPTIVE_TRACING_MODE\", \"category\": " |
| 180 "\"BENCHMARK\",\"configs\": [{\"rule\": " |
| 181 "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", \"trigger_name\":\"foo1\"}, " |
| 182 "{\"rule\": \"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\", " |
| 183 "\"trigger_name\":\"foo2\"}]}"); |
| 184 EXPECT_TRUE(config); |
| 185 EXPECT_EQ(config->mode, BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE); |
| 186 EXPECT_EQ(config->category_preset, BackgroundTracingConfig::BENCHMARK); |
| 187 EXPECT_EQ(config->configs.size(), 2u); |
| 188 EXPECT_EQ( |
| 189 config->configs[0].type, |
| 190 BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED); |
| 191 EXPECT_EQ(config->configs[0].named_trigger_info.trigger_name, "foo1"); |
| 192 EXPECT_EQ( |
| 193 config->configs[1].type, |
| 194 BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED); |
| 195 EXPECT_EQ(config->configs[1].named_trigger_info.trigger_name, "foo2"); |
| 196 } |
| 197 |
| 198 TEST_F(BackgroundTracingConfigTest, ReactiveConfigFromValidString) { |
| 199 scoped_ptr<BackgroundTracingReactiveConfig> config; |
| 200 |
| 201 config = ReadReactiveFromJSONString( |
| 202 "{\"mode\":\"REACTIVE_TRACING_MODE\", \"configs\": []}"); |
| 203 EXPECT_TRUE(config); |
| 204 EXPECT_EQ(config->mode, BackgroundTracingConfig::REACTIVE_TRACING_MODE); |
| 205 EXPECT_EQ(config->configs.size(), 0u); |
| 206 |
| 207 config = ReadReactiveFromJSONString( |
| 208 "{\"mode\":\"REACTIVE_TRACING_MODE\",\"configs\": [{\"rule\": " |
| 209 "\"TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL\", " |
| 210 "\"category\": \"BENCHMARK\", \"trigger_name\": \"foo\"}]}"); |
| 211 EXPECT_TRUE(config); |
| 212 EXPECT_EQ(config->mode, BackgroundTracingConfig::REACTIVE_TRACING_MODE); |
| 213 EXPECT_EQ(config->configs.size(), 1u); |
| 214 EXPECT_EQ(config->configs[0].type, |
| 215 BackgroundTracingReactiveConfig:: |
| 216 TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL); |
| 217 EXPECT_EQ(config->configs[0].trigger_name, "foo"); |
| 218 EXPECT_EQ(config->configs[0].category_preset, |
| 219 BackgroundTracingConfig::BENCHMARK); |
| 220 |
| 221 config = ReadReactiveFromJSONString( |
| 222 "{\"mode\":\"REACTIVE_TRACING_MODE\",\"configs\": [{\"rule\": " |
| 223 "\"TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL\", " |
| 224 "\"category\": \"BENCHMARK_DEEP\", \"trigger_name\": \"foo\"}]}"); |
| 225 EXPECT_TRUE(config); |
| 226 EXPECT_EQ(config->mode, BackgroundTracingConfig::REACTIVE_TRACING_MODE); |
| 227 EXPECT_EQ(config->configs.size(), 1u); |
| 228 EXPECT_EQ(config->configs[0].type, |
| 229 BackgroundTracingReactiveConfig:: |
| 230 TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL); |
| 231 EXPECT_EQ(config->configs[0].trigger_name, "foo"); |
| 232 EXPECT_EQ(config->configs[0].category_preset, |
| 233 BackgroundTracingConfig::BENCHMARK_DEEP); |
| 234 |
| 235 config = ReadReactiveFromJSONString( |
| 236 "{\"mode\":\"REACTIVE_TRACING_MODE\",\"configs\": [{\"rule\": " |
| 237 "\"TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL\", " |
| 238 "\"category\": \"BENCHMARK_DEEP\", \"trigger_name\": " |
| 239 "\"foo1\"},{\"rule\": " |
| 240 "\"TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL\", " |
| 241 "\"category\": \"BENCHMARK_DEEP\", \"trigger_name\": \"foo2\"}]}"); |
| 242 EXPECT_TRUE(config); |
| 243 EXPECT_EQ(config->mode, BackgroundTracingConfig::REACTIVE_TRACING_MODE); |
| 244 EXPECT_EQ(config->configs.size(), 2u); |
| 245 EXPECT_EQ(config->configs[0].type, |
| 246 BackgroundTracingReactiveConfig:: |
| 247 TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL); |
| 248 EXPECT_EQ(config->configs[0].trigger_name, "foo1"); |
| 249 EXPECT_EQ(config->configs[0].category_preset, |
| 250 BackgroundTracingConfig::BENCHMARK_DEEP); |
| 251 EXPECT_EQ(config->configs[1].type, |
| 252 BackgroundTracingReactiveConfig:: |
| 253 TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL); |
| 254 EXPECT_EQ(config->configs[1].trigger_name, "foo2"); |
| 255 EXPECT_EQ(config->configs[1].category_preset, |
| 256 BackgroundTracingConfig::BENCHMARK_DEEP); |
| 257 } |
| 258 |
| 259 TEST_F(BackgroundTracingConfigTest, ValidPreemptiveConfigToString) { |
| 260 scoped_ptr<BackgroundTracingPreemptiveConfig> config( |
| 261 new BackgroundTracingPreemptiveConfig()); |
| 262 |
| 263 // Default values |
| 264 EXPECT_EQ(ConfigToString(config.get()), |
| 265 "{\"category\":\"BENCHMARK\",\"configs\":[],\"mode\":\"PREEMPTIVE_" |
| 266 "TRACING_MODE\"}"); |
| 267 |
| 268 // Change category_preset |
| 269 config->category_preset = BackgroundTracingConfig::BENCHMARK_DEEP; |
| 270 EXPECT_EQ(ConfigToString(config.get()), |
| 271 "{\"category\":\"BENCHMARK_DEEP\",\"configs\":[],\"mode\":" |
| 272 "\"PREEMPTIVE_TRACING_MODE\"}"); |
| 273 |
| 274 { |
| 275 config.reset(new BackgroundTracingPreemptiveConfig()); |
| 276 config->category_preset = BackgroundTracingConfig::BENCHMARK_DEEP; |
| 277 |
| 278 BackgroundTracingPreemptiveConfig::MonitoringRule rule; |
| 279 rule.type = |
| 280 BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED; |
| 281 rule.named_trigger_info.trigger_name = "foo"; |
| 282 config->configs.push_back(rule); |
| 283 EXPECT_EQ(ConfigToString(config.get()), |
| 284 "{\"category\":\"BENCHMARK_DEEP\",\"configs\":[{\"rule\":" |
| 285 "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\",\"trigger_name\":" |
| 286 "\"foo\"}],\"mode\":\"PREEMPTIVE_TRACING_MODE\"}"); |
| 287 } |
| 288 |
| 289 { |
| 290 config.reset(new BackgroundTracingPreemptiveConfig()); |
| 291 config->category_preset = BackgroundTracingConfig::BENCHMARK_DEEP; |
| 292 |
| 293 BackgroundTracingPreemptiveConfig::MonitoringRule rule; |
| 294 rule.type = |
| 295 BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED; |
| 296 rule.named_trigger_info.trigger_name = "foo1"; |
| 297 config->configs.push_back(rule); |
| 298 rule.named_trigger_info.trigger_name = "foo2"; |
| 299 config->configs.push_back(rule); |
| 300 EXPECT_EQ(ConfigToString(config.get()), |
| 301 "{\"category\":\"BENCHMARK_DEEP\",\"configs\":[{\"rule\":" |
| 302 "\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\",\"trigger_name\":" |
| 303 "\"foo1\"},{\"rule\":\"MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED\"," |
| 304 "\"trigger_name\":\"foo2\"}],\"mode\":\"PREEMPTIVE_TRACING_" |
| 305 "MODE\"}"); |
| 306 } |
| 307 } |
| 308 |
| 309 TEST_F(BackgroundTracingConfigTest, InvalidPreemptiveConfigToString) { |
| 310 scoped_ptr<BackgroundTracingPreemptiveConfig> config; |
| 311 |
| 312 { |
| 313 config.reset(new BackgroundTracingPreemptiveConfig()); |
| 314 |
| 315 BackgroundTracingPreemptiveConfig::MonitoringRule rule; |
| 316 rule.type = BackgroundTracingPreemptiveConfig:: |
| 317 MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE; |
| 318 config->configs.push_back(rule); |
| 319 EXPECT_EQ(ConfigToString(config.get()), |
| 320 "{\"category\":\"BENCHMARK\",\"configs\":[],\"mode\":" |
| 321 "\"PREEMPTIVE_TRACING_MODE\"}"); |
| 322 } |
| 323 |
| 324 { |
| 325 config.reset(new BackgroundTracingPreemptiveConfig()); |
| 326 |
| 327 BackgroundTracingPreemptiveConfig::MonitoringRule rule; |
| 328 rule.type = BackgroundTracingPreemptiveConfig:: |
| 329 MONITOR_AND_DUMP_WHEN_BROWSER_STARTUP_COMPLETE; |
| 330 config->configs.push_back(rule); |
| 331 EXPECT_EQ(ConfigToString(config.get()), |
| 332 "{\"category\":\"BENCHMARK\",\"configs\":[],\"mode\":" |
| 333 "\"PREEMPTIVE_TRACING_MODE\"}"); |
| 334 } |
| 335 } |
| 336 |
| 337 TEST_F(BackgroundTracingConfigTest, ValidReactiveConfigToString) { |
| 338 scoped_ptr<BackgroundTracingReactiveConfig> config( |
| 339 new BackgroundTracingReactiveConfig()); |
| 340 |
| 341 // Default values |
| 342 EXPECT_EQ(ConfigToString(config.get()), |
| 343 "{\"configs\":[],\"mode\":\"REACTIVE_TRACING_MODE\"}"); |
| 344 |
| 345 { |
| 346 config.reset(new BackgroundTracingReactiveConfig()); |
| 347 |
| 348 BackgroundTracingReactiveConfig::TracingRule rule; |
| 349 rule.type = BackgroundTracingReactiveConfig:: |
| 350 TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL; |
| 351 rule.trigger_name = "foo"; |
| 352 rule.category_preset = BackgroundTracingConfig::BENCHMARK_DEEP; |
| 353 config->configs.push_back(rule); |
| 354 EXPECT_EQ(ConfigToString(config.get()), |
| 355 "{\"configs\":[{\"category\":\"BENCHMARK_DEEP\",\"rule\":\"TRACE_" |
| 356 "ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL\",\"trigger_" |
| 357 "name\":\"foo\"}],\"mode\":\"REACTIVE_TRACING_MODE\"}"); |
| 358 } |
| 359 |
| 360 { |
| 361 config.reset(new BackgroundTracingReactiveConfig()); |
| 362 |
| 363 BackgroundTracingReactiveConfig::TracingRule rule; |
| 364 rule.type = BackgroundTracingReactiveConfig:: |
| 365 TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL; |
| 366 rule.trigger_name = "foo1"; |
| 367 rule.category_preset = BackgroundTracingConfig::BENCHMARK_DEEP; |
| 368 config->configs.push_back(rule); |
| 369 rule.trigger_name = "foo2"; |
| 370 config->configs.push_back(rule); |
| 371 EXPECT_EQ(ConfigToString(config.get()), |
| 372 "{\"configs\":[{\"category\":\"BENCHMARK_DEEP\",\"rule\":\"TRACE_" |
| 373 "ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL\",\"trigger_" |
| 374 "name\":\"foo1\"},{\"category\":\"BENCHMARK_DEEP\",\"rule\":" |
| 375 "\"TRACE_ON_MANUAL_TRIGGER_UNTIL_10S_OR_NEXT_TRIGGER_OR_FULL\"," |
| 376 "\"trigger_name\":\"foo2\"}],\"mode\":\"REACTIVE_TRACING_" |
| 377 "MODE\"}"); |
| 378 } |
| 379 } |
| 380 |
| 381 } // namspace content |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1162623002:
Implement FromDict/IntoDict for BackgroundTracingConfig. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master