OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/bind.h" | 5 #include "base/bind.h" |
| 6 #include "base/trace_event/trace_event.h" |
6 #include "content/public/browser/background_tracing_manager.h" | 7 #include "content/public/browser/background_tracing_manager.h" |
7 #include "content/public/browser/background_tracing_preemptive_config.h" | 8 #include "content/public/browser/background_tracing_preemptive_config.h" |
8 #include "content/public/browser/background_tracing_reactive_config.h" | 9 #include "content/public/browser/background_tracing_reactive_config.h" |
9 #include "content/public/test/content_browser_test.h" | 10 #include "content/public/test/content_browser_test.h" |
10 #include "content/public/test/content_browser_test_utils.h" | 11 #include "content/public/test/content_browser_test_utils.h" |
11 #include "content/public/test/test_utils.h" | 12 #include "content/public/test/test_utils.h" |
| 13 #include "third_party/zlib/zlib.h" |
12 | 14 |
13 namespace content { | 15 namespace content { |
14 | 16 |
15 class BackgroundTracingManagerBrowserTest : public ContentBrowserTest { | 17 class BackgroundTracingManagerBrowserTest : public ContentBrowserTest { |
16 public: | 18 public: |
17 BackgroundTracingManagerBrowserTest() {} | 19 BackgroundTracingManagerBrowserTest() {} |
18 | 20 |
19 private: | 21 private: |
20 DISALLOW_COPY_AND_ASSIGN(BackgroundTracingManagerBrowserTest); | 22 DISALLOW_COPY_AND_ASSIGN(BackgroundTracingManagerBrowserTest); |
21 }; | 23 }; |
22 | 24 |
23 class BackgroundTracingManagerUploadConfigWrapper { | 25 class BackgroundTracingManagerUploadConfigWrapper { |
24 public: | 26 public: |
25 BackgroundTracingManagerUploadConfigWrapper(const base::Closure& callback) | 27 BackgroundTracingManagerUploadConfigWrapper(const base::Closure& callback) |
26 : callback_(callback), receive_count_(0) { | 28 : callback_(callback), receive_count_(0) { |
27 receive_callback_ = | 29 receive_callback_ = |
28 base::Bind(&BackgroundTracingManagerUploadConfigWrapper::Upload, | 30 base::Bind(&BackgroundTracingManagerUploadConfigWrapper::Upload, |
29 base::Unretained(this)); | 31 base::Unretained(this)); |
30 } | 32 } |
31 | 33 |
32 void Upload(const base::RefCountedString* file_contents, | 34 void Upload(const scoped_refptr<base::RefCountedString>& file_contents, |
33 base::Callback<void()> done_callback) { | 35 base::Callback<void()> done_callback) { |
34 receive_count_ += 1; | 36 receive_count_ += 1; |
| 37 EXPECT_TRUE(file_contents); |
35 | 38 |
| 39 size_t compressed_length = file_contents->data().length(); |
| 40 const size_t output_buffer_length = 10 * 1024 * 1024; |
| 41 std::vector<char> output_str(output_buffer_length); |
| 42 |
| 43 z_stream stream = {0}; |
| 44 stream.total_in = stream.avail_in = compressed_length; |
| 45 stream.total_out = stream.avail_out = output_buffer_length; |
| 46 stream.next_in = (Bytef*)&file_contents->data()[0]; |
| 47 stream.next_out = (Bytef*)&output_str[0]; |
| 48 |
| 49 stream.zalloc = Z_NULL; |
| 50 stream.zfree = Z_NULL; |
| 51 stream.opaque = Z_NULL; |
| 52 |
| 53 int result = inflateInit2(&stream, 16 + MAX_WBITS); |
| 54 EXPECT_EQ(Z_OK, result); |
| 55 result = inflate(&stream, Z_FINISH); |
| 56 bool success = (result != Z_STREAM_ERROR); |
| 57 inflateEnd(&stream); |
| 58 EXPECT_TRUE(success); |
| 59 |
| 60 last_file_contents_ = &output_str[0]; |
36 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | 61 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, |
37 base::Bind(done_callback)); | 62 base::Bind(done_callback)); |
38 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | 63 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, |
39 base::Bind(callback_)); | 64 base::Bind(callback_)); |
40 } | 65 } |
41 | 66 |
| 67 bool TraceHasMatchingString(const char* str) { |
| 68 return last_file_contents_.find(str) != std::string::npos; |
| 69 } |
| 70 |
42 int get_receive_count() const { return receive_count_; } | 71 int get_receive_count() const { return receive_count_; } |
43 | 72 |
44 const BackgroundTracingManager::ReceiveCallback& get_receive_callback() | 73 const BackgroundTracingManager::ReceiveCallback& get_receive_callback() |
45 const { | 74 const { |
46 return receive_callback_; | 75 return receive_callback_; |
47 } | 76 } |
48 | 77 |
49 private: | 78 private: |
50 BackgroundTracingManager::ReceiveCallback receive_callback_; | 79 BackgroundTracingManager::ReceiveCallback receive_callback_; |
51 base::Closure callback_; | 80 base::Closure callback_; |
52 int receive_count_; | 81 int receive_count_; |
| 82 std::string last_file_contents_; |
53 }; | 83 }; |
54 | 84 |
55 void StartedFinalizingCallback(base::Closure callback, | 85 void StartedFinalizingCallback(base::Closure callback, |
56 bool expected, | 86 bool expected, |
57 bool value) { | 87 bool value) { |
58 EXPECT_EQ(expected, value); | 88 EXPECT_EQ(expected, value); |
59 if (!callback.is_null()) | 89 if (!callback.is_null()) |
60 callback.Run(); | 90 callback.Run(); |
61 } | 91 } |
62 | 92 |
(...skipping 11 matching lines...) Expand all Loading... |
74 return config.Pass(); | 104 return config.Pass(); |
75 } | 105 } |
76 | 106 |
77 void SetupBackgroundTracingManager() { | 107 void SetupBackgroundTracingManager() { |
78 content::BackgroundTracingManager::GetInstance() | 108 content::BackgroundTracingManager::GetInstance() |
79 ->InvalidateTriggerHandlesForTesting(); | 109 ->InvalidateTriggerHandlesForTesting(); |
80 } | 110 } |
81 | 111 |
82 void DisableScenarioWhenIdle() { | 112 void DisableScenarioWhenIdle() { |
83 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 113 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
84 NULL, BackgroundTracingManager::ReceiveCallback(), false); | 114 NULL, BackgroundTracingManager::ReceiveCallback(), base::Closure(), |
| 115 BackgroundTracingManager::NO_DATA_FILTERING); |
85 } | 116 } |
86 | 117 |
87 // This tests that the endpoint receives the final trace data. | 118 // This tests that the endpoint receives the final trace data. |
88 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, | 119 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
89 ReceiveTraceFinalContentsOnTrigger) { | 120 ReceiveTraceFinalContentsOnTrigger) { |
90 { | 121 { |
91 SetupBackgroundTracingManager(); | 122 SetupBackgroundTracingManager(); |
92 | 123 |
93 base::RunLoop run_loop; | 124 base::RunLoop run_loop; |
94 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( | 125 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
95 run_loop.QuitClosure()); | 126 run_loop.QuitClosure()); |
96 | 127 |
97 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | 128 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
98 CreatePreemptiveConfig(); | 129 CreatePreemptiveConfig(); |
99 | 130 |
100 BackgroundTracingManager::TriggerHandle handle = | 131 BackgroundTracingManager::TriggerHandle handle = |
101 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test"); | 132 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test"); |
102 | 133 |
103 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 134 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
104 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 135 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 136 base::Closure(), BackgroundTracingManager::NO_DATA_FILTERING); |
105 | 137 |
106 BackgroundTracingManager::GetInstance()->WhenIdle( | 138 BackgroundTracingManager::GetInstance()->WhenIdle( |
107 base::Bind(&DisableScenarioWhenIdle)); | 139 base::Bind(&DisableScenarioWhenIdle)); |
108 | 140 |
109 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 141 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
110 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 142 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
111 | 143 |
112 run_loop.Run(); | 144 run_loop.Run(); |
113 | 145 |
114 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); | 146 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); |
(...skipping 11 matching lines...) Expand all Loading... |
126 run_loop.QuitClosure()); | 158 run_loop.QuitClosure()); |
127 | 159 |
128 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | 160 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
129 CreatePreemptiveConfig(); | 161 CreatePreemptiveConfig(); |
130 | 162 |
131 content::BackgroundTracingManager::TriggerHandle handle = | 163 content::BackgroundTracingManager::TriggerHandle handle = |
132 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( | 164 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
133 "test"); | 165 "test"); |
134 | 166 |
135 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 167 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
136 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 168 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 169 base::Closure(), BackgroundTracingManager::NO_DATA_FILTERING); |
137 | 170 |
138 BackgroundTracingManager::GetInstance()->WhenIdle( | 171 BackgroundTracingManager::GetInstance()->WhenIdle( |
139 base::Bind(&DisableScenarioWhenIdle)); | 172 base::Bind(&DisableScenarioWhenIdle)); |
140 | 173 |
141 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 174 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
142 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 175 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
143 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 176 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
144 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false)); | 177 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false)); |
145 | 178 |
146 run_loop.Run(); | 179 run_loop.Run(); |
147 | 180 |
148 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); | 181 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); |
149 } | 182 } |
150 } | 183 } |
151 | 184 |
| 185 namespace { |
| 186 |
| 187 bool IsTraceEventArgsWhitelisted(const char* category_group_name, |
| 188 const char* event_name) { |
| 189 if (MatchPattern(category_group_name, "benchmark") && |
| 190 MatchPattern(event_name, "whitelisted")) { |
| 191 return true; |
| 192 } |
| 193 |
| 194 return false; |
| 195 } |
| 196 |
| 197 } // namespace |
| 198 |
| 199 // This tests that non-whitelisted args get stripped if required. |
| 200 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
| 201 NoWhitelistedArgsStripped) { |
| 202 { |
| 203 SetupBackgroundTracingManager(); |
| 204 |
| 205 base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate( |
| 206 base::Bind(&IsTraceEventArgsWhitelisted)); |
| 207 |
| 208 base::RunLoop wait_for_upload; |
| 209 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
| 210 wait_for_upload.QuitClosure()); |
| 211 |
| 212 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
| 213 CreatePreemptiveConfig(); |
| 214 |
| 215 content::BackgroundTracingManager::TriggerHandle handle = |
| 216 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
| 217 "test"); |
| 218 |
| 219 base::RunLoop wait_for_activated; |
| 220 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
| 221 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 222 wait_for_activated.QuitClosure(), |
| 223 BackgroundTracingManager::ANONYMIZE_DATA); |
| 224 |
| 225 wait_for_activated.Run(); |
| 226 |
| 227 TRACE_EVENT1("benchmark", "whitelisted", "find_this", 1); |
| 228 TRACE_EVENT1("benchmark", "not_whitelisted", "this_not_found", 1); |
| 229 |
| 230 BackgroundTracingManager::GetInstance()->WhenIdle( |
| 231 base::Bind(&DisableScenarioWhenIdle)); |
| 232 |
| 233 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
| 234 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
| 235 |
| 236 wait_for_upload.Run(); |
| 237 |
| 238 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); |
| 239 EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("{")); |
| 240 EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("find_this")); |
| 241 EXPECT_TRUE( |
| 242 !upload_config_wrapper.TraceHasMatchingString("this_not_found")); |
| 243 } |
| 244 } |
| 245 |
| 246 // This tests subprocesses (like a navigating renderer) which gets told to |
| 247 // provide a argument-filtered trace and has no predicate in place to do the |
| 248 // filtering (in this case, only the browser process gets it set), will crash |
| 249 // rather than return potential PII. |
| 250 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
| 251 CrashWhenSubprocessWithoutArgumentFilter) { |
| 252 { |
| 253 SetupBackgroundTracingManager(); |
| 254 |
| 255 base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate( |
| 256 base::Bind(&IsTraceEventArgsWhitelisted)); |
| 257 |
| 258 base::RunLoop wait_for_upload; |
| 259 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
| 260 wait_for_upload.QuitClosure()); |
| 261 |
| 262 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
| 263 CreatePreemptiveConfig(); |
| 264 |
| 265 content::BackgroundTracingManager::TriggerHandle handle = |
| 266 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
| 267 "test"); |
| 268 |
| 269 base::RunLoop wait_for_activated; |
| 270 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
| 271 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 272 wait_for_activated.QuitClosure(), |
| 273 BackgroundTracingManager::ANONYMIZE_DATA); |
| 274 |
| 275 wait_for_activated.Run(); |
| 276 |
| 277 NavigateToURL(shell(), GetTestUrl("", "about:blank")); |
| 278 |
| 279 BackgroundTracingManager::GetInstance()->WhenIdle( |
| 280 base::Bind(&DisableScenarioWhenIdle)); |
| 281 |
| 282 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
| 283 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
| 284 |
| 285 wait_for_upload.Run(); |
| 286 |
| 287 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); |
| 288 // We should *not* receive anything at all from the renderer, |
| 289 // the process should've crashed rather than letting that happen. |
| 290 EXPECT_TRUE( |
| 291 !upload_config_wrapper.TraceHasMatchingString("CrRendererMain")); |
| 292 } |
| 293 } |
| 294 |
152 // This tests multiple triggers still only gathers once. | 295 // This tests multiple triggers still only gathers once. |
153 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, | 296 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
154 CallMultipleTriggersOnlyGatherOnce) { | 297 CallMultipleTriggersOnlyGatherOnce) { |
155 { | 298 { |
156 SetupBackgroundTracingManager(); | 299 SetupBackgroundTracingManager(); |
157 | 300 |
158 base::RunLoop run_loop; | 301 base::RunLoop run_loop; |
159 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( | 302 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
160 run_loop.QuitClosure()); | 303 run_loop.QuitClosure()); |
161 | 304 |
162 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | 305 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
163 CreatePreemptiveConfig(); | 306 CreatePreemptiveConfig(); |
164 | 307 |
165 BackgroundTracingPreemptiveConfig::MonitoringRule rule; | 308 BackgroundTracingPreemptiveConfig::MonitoringRule rule; |
166 rule.type = | 309 rule.type = |
167 BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED; | 310 BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED; |
168 rule.named_trigger_info.trigger_name = "test1"; | 311 rule.named_trigger_info.trigger_name = "test1"; |
169 config->configs.push_back(rule); | 312 config->configs.push_back(rule); |
170 | 313 |
171 rule.named_trigger_info.trigger_name = "test2"; | 314 rule.named_trigger_info.trigger_name = "test2"; |
172 config->configs.push_back(rule); | 315 config->configs.push_back(rule); |
173 | 316 |
174 BackgroundTracingManager::TriggerHandle handle1 = | 317 BackgroundTracingManager::TriggerHandle handle1 = |
175 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test1"); | 318 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test1"); |
176 BackgroundTracingManager::TriggerHandle handle2 = | 319 BackgroundTracingManager::TriggerHandle handle2 = |
177 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test2"); | 320 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test2"); |
178 | 321 |
179 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 322 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
180 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 323 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 324 base::Closure(), BackgroundTracingManager::NO_DATA_FILTERING); |
181 | 325 |
182 BackgroundTracingManager::GetInstance()->WhenIdle( | 326 BackgroundTracingManager::GetInstance()->WhenIdle( |
183 base::Bind(&DisableScenarioWhenIdle)); | 327 base::Bind(&DisableScenarioWhenIdle)); |
184 | 328 |
185 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 329 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
186 handle1, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 330 handle1, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
187 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 331 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
188 handle2, | 332 handle2, |
189 base::Bind(&StartedFinalizingCallback, base::Closure(), false)); | 333 base::Bind(&StartedFinalizingCallback, base::Closure(), false)); |
190 | 334 |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
232 (base::Closure())); | 376 (base::Closure())); |
233 | 377 |
234 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | 378 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
235 CreatePreemptiveConfig(); | 379 CreatePreemptiveConfig(); |
236 | 380 |
237 content::BackgroundTracingManager::TriggerHandle handle = | 381 content::BackgroundTracingManager::TriggerHandle handle = |
238 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( | 382 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
239 "does_not_exist"); | 383 "does_not_exist"); |
240 | 384 |
241 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 385 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
242 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 386 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 387 base::Closure(), BackgroundTracingManager::NO_DATA_FILTERING); |
243 | 388 |
244 BackgroundTracingManager::GetInstance()->WhenIdle( | 389 BackgroundTracingManager::GetInstance()->WhenIdle( |
245 base::Bind(&DisableScenarioWhenIdle)); | 390 base::Bind(&DisableScenarioWhenIdle)); |
246 | 391 |
247 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 392 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
248 handle, | 393 handle, |
249 base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false)); | 394 base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false)); |
250 | 395 |
251 run_loop.Run(); | 396 run_loop.Run(); |
252 | 397 |
(...skipping 15 matching lines...) Expand all Loading... |
268 CreatePreemptiveConfig(); | 413 CreatePreemptiveConfig(); |
269 | 414 |
270 content::BackgroundTracingManager::TriggerHandle handle = | 415 content::BackgroundTracingManager::TriggerHandle handle = |
271 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( | 416 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
272 "test"); | 417 "test"); |
273 | 418 |
274 content::BackgroundTracingManager::GetInstance() | 419 content::BackgroundTracingManager::GetInstance() |
275 ->InvalidateTriggerHandlesForTesting(); | 420 ->InvalidateTriggerHandlesForTesting(); |
276 | 421 |
277 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 422 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
278 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 423 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 424 base::Closure(), BackgroundTracingManager::NO_DATA_FILTERING); |
279 | 425 |
280 BackgroundTracingManager::GetInstance()->WhenIdle( | 426 BackgroundTracingManager::GetInstance()->WhenIdle( |
281 base::Bind(&DisableScenarioWhenIdle)); | 427 base::Bind(&DisableScenarioWhenIdle)); |
282 | 428 |
283 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 429 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
284 handle, | 430 handle, |
285 base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false)); | 431 base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false)); |
286 | 432 |
287 run_loop.Run(); | 433 run_loop.Run(); |
288 | 434 |
(...skipping 14 matching lines...) Expand all Loading... |
303 new content::BackgroundTracingPreemptiveConfig()); | 449 new content::BackgroundTracingPreemptiveConfig()); |
304 | 450 |
305 BackgroundTracingPreemptiveConfig::MonitoringRule rule; | 451 BackgroundTracingPreemptiveConfig::MonitoringRule rule; |
306 rule.type = BackgroundTracingPreemptiveConfig:: | 452 rule.type = BackgroundTracingPreemptiveConfig:: |
307 MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE; | 453 MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE; |
308 rule.histogram_trigger_info.histogram_name_to_trigger_on = "fake"; | 454 rule.histogram_trigger_info.histogram_name_to_trigger_on = "fake"; |
309 rule.histogram_trigger_info.histogram_bin_to_trigger_on = 0; | 455 rule.histogram_trigger_info.histogram_bin_to_trigger_on = 0; |
310 config->configs.push_back(rule); | 456 config->configs.push_back(rule); |
311 | 457 |
312 bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario( | 458 bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario( |
313 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 459 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 460 base::Closure(), BackgroundTracingManager::NO_DATA_FILTERING); |
314 | 461 |
315 EXPECT_FALSE(result); | 462 EXPECT_FALSE(result); |
316 } | 463 } |
317 } | 464 } |
318 | 465 |
319 // This tests that reactive mode configs will fail. | 466 // This tests that reactive mode configs will fail. |
320 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, | 467 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
321 DoesNotAllowReactiveConfig) { | 468 DoesNotAllowReactiveConfig) { |
322 { | 469 { |
323 SetupBackgroundTracingManager(); | 470 SetupBackgroundTracingManager(); |
324 | 471 |
325 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( | 472 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
326 (base::Closure())); | 473 (base::Closure())); |
327 | 474 |
328 scoped_ptr<BackgroundTracingConfig> config( | 475 scoped_ptr<BackgroundTracingConfig> config( |
329 new BackgroundTracingReactiveConfig()); | 476 new BackgroundTracingReactiveConfig()); |
330 | 477 |
331 bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario( | 478 bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario( |
332 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 479 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 480 base::Closure(), BackgroundTracingManager::NO_DATA_FILTERING); |
333 | 481 |
334 EXPECT_FALSE(result); | 482 EXPECT_FALSE(result); |
335 } | 483 } |
336 } | 484 } |
337 | 485 |
338 } // namespace content | 486 } // namespace content |
OLD | NEW |