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; | |
davidben
2015/06/05 16:40:06
Style nit: kOutputBufferLength
| |
41 std::vector<char> output_str(output_buffer_length); | |
42 | |
43 z_stream stream = {0}; | |
44 stream.avail_in = compressed_length; | |
45 stream.avail_out = output_buffer_length; | |
46 stream.next_in = (Bytef*)&file_contents->data()[0]; | |
47 stream.next_out = (Bytef*)vector_as_array(&output_str); | |
48 | |
49 // 16 + MAX_WBITS means only decoding gzip encoded streams, and using | |
50 // the biggest window size, according to zlib.h | |
51 int result = inflateInit2(&stream, 16 + MAX_WBITS); | |
52 EXPECT_EQ(Z_OK, result); | |
53 result = inflate(&stream, Z_FINISH); | |
54 int bytes_written = output_buffer_length - stream.avail_out; | |
55 | |
56 inflateEnd(&stream); | |
57 EXPECT_EQ(Z_STREAM_END, result); | |
58 | |
59 last_file_contents_.assign(vector_as_array(&output_str), bytes_written); | |
36 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | 60 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, |
37 base::Bind(done_callback)); | 61 base::Bind(done_callback)); |
38 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | 62 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, |
39 base::Bind(callback_)); | 63 base::Bind(callback_)); |
40 } | 64 } |
41 | 65 |
66 bool TraceHasMatchingString(const char* str) { | |
67 return last_file_contents_.find(str) != std::string::npos; | |
68 } | |
69 | |
42 int get_receive_count() const { return receive_count_; } | 70 int get_receive_count() const { return receive_count_; } |
43 | 71 |
44 const BackgroundTracingManager::ReceiveCallback& get_receive_callback() | 72 const BackgroundTracingManager::ReceiveCallback& get_receive_callback() |
45 const { | 73 const { |
46 return receive_callback_; | 74 return receive_callback_; |
47 } | 75 } |
48 | 76 |
49 private: | 77 private: |
50 BackgroundTracingManager::ReceiveCallback receive_callback_; | 78 BackgroundTracingManager::ReceiveCallback receive_callback_; |
51 base::Closure callback_; | 79 base::Closure callback_; |
52 int receive_count_; | 80 int receive_count_; |
81 std::string last_file_contents_; | |
53 }; | 82 }; |
54 | 83 |
55 void StartedFinalizingCallback(base::Closure callback, | 84 void StartedFinalizingCallback(base::Closure callback, |
56 bool expected, | 85 bool expected, |
57 bool value) { | 86 bool value) { |
58 EXPECT_EQ(expected, value); | 87 EXPECT_EQ(expected, value); |
59 if (!callback.is_null()) | 88 if (!callback.is_null()) |
60 callback.Run(); | 89 callback.Run(); |
61 } | 90 } |
62 | 91 |
(...skipping 11 matching lines...) Expand all Loading... | |
74 return config.Pass(); | 103 return config.Pass(); |
75 } | 104 } |
76 | 105 |
77 void SetupBackgroundTracingManager() { | 106 void SetupBackgroundTracingManager() { |
78 content::BackgroundTracingManager::GetInstance() | 107 content::BackgroundTracingManager::GetInstance() |
79 ->InvalidateTriggerHandlesForTesting(); | 108 ->InvalidateTriggerHandlesForTesting(); |
80 } | 109 } |
81 | 110 |
82 void DisableScenarioWhenIdle() { | 111 void DisableScenarioWhenIdle() { |
83 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 112 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
84 NULL, BackgroundTracingManager::ReceiveCallback(), false); | 113 NULL, BackgroundTracingManager::ReceiveCallback(), base::Closure(), |
114 false); | |
85 } | 115 } |
86 | 116 |
87 // This tests that the endpoint receives the final trace data. | 117 // This tests that the endpoint receives the final trace data. |
88 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, | 118 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
89 ReceiveTraceFinalContentsOnTrigger) { | 119 ReceiveTraceFinalContentsOnTrigger) { |
90 { | 120 { |
91 SetupBackgroundTracingManager(); | 121 SetupBackgroundTracingManager(); |
92 | 122 |
93 base::RunLoop run_loop; | 123 base::RunLoop run_loop; |
94 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( | 124 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
95 run_loop.QuitClosure()); | 125 run_loop.QuitClosure()); |
96 | 126 |
97 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | 127 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
98 CreatePreemptiveConfig(); | 128 CreatePreemptiveConfig(); |
99 | 129 |
100 BackgroundTracingManager::TriggerHandle handle = | 130 BackgroundTracingManager::TriggerHandle handle = |
101 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test"); | 131 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test"); |
102 | 132 |
103 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 133 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
104 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 134 config.Pass(), upload_config_wrapper.get_receive_callback(), |
135 base::Closure(), false); | |
105 | 136 |
106 BackgroundTracingManager::GetInstance()->WhenIdle( | 137 BackgroundTracingManager::GetInstance()->WhenIdle( |
107 base::Bind(&DisableScenarioWhenIdle)); | 138 base::Bind(&DisableScenarioWhenIdle)); |
108 | 139 |
109 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 140 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
110 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 141 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
111 | 142 |
112 run_loop.Run(); | 143 run_loop.Run(); |
113 | 144 |
114 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); | 145 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); |
(...skipping 11 matching lines...) Expand all Loading... | |
126 run_loop.QuitClosure()); | 157 run_loop.QuitClosure()); |
127 | 158 |
128 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | 159 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
129 CreatePreemptiveConfig(); | 160 CreatePreemptiveConfig(); |
130 | 161 |
131 content::BackgroundTracingManager::TriggerHandle handle = | 162 content::BackgroundTracingManager::TriggerHandle handle = |
132 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( | 163 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
133 "test"); | 164 "test"); |
134 | 165 |
135 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 166 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
136 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 167 config.Pass(), upload_config_wrapper.get_receive_callback(), |
168 base::Closure(), false); | |
137 | 169 |
138 BackgroundTracingManager::GetInstance()->WhenIdle( | 170 BackgroundTracingManager::GetInstance()->WhenIdle( |
139 base::Bind(&DisableScenarioWhenIdle)); | 171 base::Bind(&DisableScenarioWhenIdle)); |
140 | 172 |
141 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 173 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
142 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 174 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
143 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 175 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
144 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false)); | 176 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false)); |
145 | 177 |
146 run_loop.Run(); | 178 run_loop.Run(); |
147 | 179 |
148 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); | 180 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); |
149 } | 181 } |
150 } | 182 } |
151 | 183 |
184 namespace { | |
185 | |
186 bool IsTraceEventArgsWhitelisted(const char* category_group_name, | |
187 const char* event_name) { | |
188 if (MatchPattern(category_group_name, "benchmark") && | |
189 MatchPattern(event_name, "whitelisted")) { | |
190 return true; | |
191 } | |
192 | |
193 return false; | |
194 } | |
195 | |
196 } // namespace | |
197 | |
198 // This tests that non-whitelisted args get stripped if required. | |
199 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, | |
200 NoWhitelistedArgsStripped) { | |
201 SetupBackgroundTracingManager(); | |
202 | |
203 base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate( | |
204 base::Bind(&IsTraceEventArgsWhitelisted)); | |
205 | |
206 base::RunLoop wait_for_upload; | |
207 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( | |
208 wait_for_upload.QuitClosure()); | |
209 | |
210 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | |
211 CreatePreemptiveConfig(); | |
212 | |
213 content::BackgroundTracingManager::TriggerHandle handle = | |
214 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( | |
215 "test"); | |
216 | |
217 base::RunLoop wait_for_activated; | |
218 BackgroundTracingManager::GetInstance()->SetActiveScenario( | |
219 config.Pass(), upload_config_wrapper.get_receive_callback(), | |
220 wait_for_activated.QuitClosure(), true); | |
221 | |
222 wait_for_activated.Run(); | |
223 | |
224 TRACE_EVENT1("benchmark", "whitelisted", "find_this", 1); | |
225 TRACE_EVENT1("benchmark", "not_whitelisted", "this_not_found", 1); | |
226 | |
227 BackgroundTracingManager::GetInstance()->WhenIdle( | |
228 base::Bind(&DisableScenarioWhenIdle)); | |
229 | |
230 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | |
231 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | |
232 | |
233 wait_for_upload.Run(); | |
234 | |
235 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); | |
236 EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("{")); | |
237 EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("find_this")); | |
238 EXPECT_TRUE(!upload_config_wrapper.TraceHasMatchingString("this_not_found")); | |
239 } | |
240 | |
241 // This tests subprocesses (like a navigating renderer) which gets told to | |
242 // provide a argument-filtered trace and has no predicate in place to do the | |
243 // filtering (in this case, only the browser process gets it set), will crash | |
244 // rather than return potential PII. | |
245 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, | |
246 CrashWhenSubprocessWithoutArgumentFilter) { | |
247 SetupBackgroundTracingManager(); | |
248 | |
249 base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate( | |
250 base::Bind(&IsTraceEventArgsWhitelisted)); | |
251 | |
252 base::RunLoop wait_for_upload; | |
253 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( | |
254 wait_for_upload.QuitClosure()); | |
255 | |
256 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | |
257 CreatePreemptiveConfig(); | |
258 | |
259 content::BackgroundTracingManager::TriggerHandle handle = | |
260 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( | |
261 "test"); | |
262 | |
263 base::RunLoop wait_for_activated; | |
264 BackgroundTracingManager::GetInstance()->SetActiveScenario( | |
265 config.Pass(), upload_config_wrapper.get_receive_callback(), | |
266 wait_for_activated.QuitClosure(), true); | |
267 | |
268 wait_for_activated.Run(); | |
269 | |
270 NavigateToURL(shell(), GetTestUrl("", "about:blank")); | |
271 | |
272 BackgroundTracingManager::GetInstance()->WhenIdle( | |
273 base::Bind(&DisableScenarioWhenIdle)); | |
274 | |
275 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | |
276 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | |
277 | |
278 wait_for_upload.Run(); | |
279 | |
280 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); | |
281 // We should *not* receive anything at all from the renderer, | |
282 // the process should've crashed rather than letting that happen. | |
283 EXPECT_TRUE(!upload_config_wrapper.TraceHasMatchingString("CrRendererMain")); | |
284 } | |
285 | |
152 // This tests multiple triggers still only gathers once. | 286 // This tests multiple triggers still only gathers once. |
153 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, | 287 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
154 CallMultipleTriggersOnlyGatherOnce) { | 288 CallMultipleTriggersOnlyGatherOnce) { |
155 { | 289 { |
156 SetupBackgroundTracingManager(); | 290 SetupBackgroundTracingManager(); |
157 | 291 |
158 base::RunLoop run_loop; | 292 base::RunLoop run_loop; |
159 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( | 293 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
160 run_loop.QuitClosure()); | 294 run_loop.QuitClosure()); |
161 | 295 |
162 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | 296 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
163 CreatePreemptiveConfig(); | 297 CreatePreemptiveConfig(); |
164 | 298 |
165 BackgroundTracingPreemptiveConfig::MonitoringRule rule; | 299 BackgroundTracingPreemptiveConfig::MonitoringRule rule; |
166 rule.type = | 300 rule.type = |
167 BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED; | 301 BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED; |
168 rule.named_trigger_info.trigger_name = "test1"; | 302 rule.named_trigger_info.trigger_name = "test1"; |
169 config->configs.push_back(rule); | 303 config->configs.push_back(rule); |
170 | 304 |
171 rule.named_trigger_info.trigger_name = "test2"; | 305 rule.named_trigger_info.trigger_name = "test2"; |
172 config->configs.push_back(rule); | 306 config->configs.push_back(rule); |
173 | 307 |
174 BackgroundTracingManager::TriggerHandle handle1 = | 308 BackgroundTracingManager::TriggerHandle handle1 = |
175 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test1"); | 309 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test1"); |
176 BackgroundTracingManager::TriggerHandle handle2 = | 310 BackgroundTracingManager::TriggerHandle handle2 = |
177 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test2"); | 311 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test2"); |
178 | 312 |
179 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 313 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
180 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 314 config.Pass(), upload_config_wrapper.get_receive_callback(), |
315 base::Closure(), false); | |
181 | 316 |
182 BackgroundTracingManager::GetInstance()->WhenIdle( | 317 BackgroundTracingManager::GetInstance()->WhenIdle( |
183 base::Bind(&DisableScenarioWhenIdle)); | 318 base::Bind(&DisableScenarioWhenIdle)); |
184 | 319 |
185 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 320 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
186 handle1, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 321 handle1, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
187 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 322 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
188 handle2, | 323 handle2, |
189 base::Bind(&StartedFinalizingCallback, base::Closure(), false)); | 324 base::Bind(&StartedFinalizingCallback, base::Closure(), false)); |
190 | 325 |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
232 (base::Closure())); | 367 (base::Closure())); |
233 | 368 |
234 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | 369 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
235 CreatePreemptiveConfig(); | 370 CreatePreemptiveConfig(); |
236 | 371 |
237 content::BackgroundTracingManager::TriggerHandle handle = | 372 content::BackgroundTracingManager::TriggerHandle handle = |
238 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( | 373 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
239 "does_not_exist"); | 374 "does_not_exist"); |
240 | 375 |
241 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 376 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
242 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 377 config.Pass(), upload_config_wrapper.get_receive_callback(), |
378 base::Closure(), false); | |
243 | 379 |
244 BackgroundTracingManager::GetInstance()->WhenIdle( | 380 BackgroundTracingManager::GetInstance()->WhenIdle( |
245 base::Bind(&DisableScenarioWhenIdle)); | 381 base::Bind(&DisableScenarioWhenIdle)); |
246 | 382 |
247 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 383 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
248 handle, | 384 handle, |
249 base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false)); | 385 base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false)); |
250 | 386 |
251 run_loop.Run(); | 387 run_loop.Run(); |
252 | 388 |
(...skipping 15 matching lines...) Expand all Loading... | |
268 CreatePreemptiveConfig(); | 404 CreatePreemptiveConfig(); |
269 | 405 |
270 content::BackgroundTracingManager::TriggerHandle handle = | 406 content::BackgroundTracingManager::TriggerHandle handle = |
271 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( | 407 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
272 "test"); | 408 "test"); |
273 | 409 |
274 content::BackgroundTracingManager::GetInstance() | 410 content::BackgroundTracingManager::GetInstance() |
275 ->InvalidateTriggerHandlesForTesting(); | 411 ->InvalidateTriggerHandlesForTesting(); |
276 | 412 |
277 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 413 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
278 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 414 config.Pass(), upload_config_wrapper.get_receive_callback(), |
415 base::Closure(), false); | |
279 | 416 |
280 BackgroundTracingManager::GetInstance()->WhenIdle( | 417 BackgroundTracingManager::GetInstance()->WhenIdle( |
281 base::Bind(&DisableScenarioWhenIdle)); | 418 base::Bind(&DisableScenarioWhenIdle)); |
282 | 419 |
283 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 420 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
284 handle, | 421 handle, |
285 base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false)); | 422 base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false)); |
286 | 423 |
287 run_loop.Run(); | 424 run_loop.Run(); |
288 | 425 |
(...skipping 14 matching lines...) Expand all Loading... | |
303 new content::BackgroundTracingPreemptiveConfig()); | 440 new content::BackgroundTracingPreemptiveConfig()); |
304 | 441 |
305 BackgroundTracingPreemptiveConfig::MonitoringRule rule; | 442 BackgroundTracingPreemptiveConfig::MonitoringRule rule; |
306 rule.type = BackgroundTracingPreemptiveConfig:: | 443 rule.type = BackgroundTracingPreemptiveConfig:: |
307 MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE; | 444 MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE; |
308 rule.histogram_trigger_info.histogram_name_to_trigger_on = "fake"; | 445 rule.histogram_trigger_info.histogram_name_to_trigger_on = "fake"; |
309 rule.histogram_trigger_info.histogram_bin_to_trigger_on = 0; | 446 rule.histogram_trigger_info.histogram_bin_to_trigger_on = 0; |
310 config->configs.push_back(rule); | 447 config->configs.push_back(rule); |
311 | 448 |
312 bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario( | 449 bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario( |
313 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 450 config.Pass(), upload_config_wrapper.get_receive_callback(), |
451 base::Closure(), false); | |
314 | 452 |
315 EXPECT_FALSE(result); | 453 EXPECT_FALSE(result); |
316 } | 454 } |
317 } | 455 } |
318 | 456 |
319 // This tests that reactive mode configs will fail. | 457 // This tests that reactive mode configs will fail. |
320 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, | 458 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
321 DoesNotAllowReactiveConfig) { | 459 DoesNotAllowReactiveConfig) { |
322 { | 460 { |
323 SetupBackgroundTracingManager(); | 461 SetupBackgroundTracingManager(); |
324 | 462 |
325 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( | 463 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
326 (base::Closure())); | 464 (base::Closure())); |
327 | 465 |
328 scoped_ptr<BackgroundTracingConfig> config( | 466 scoped_ptr<BackgroundTracingConfig> config( |
329 new BackgroundTracingReactiveConfig()); | 467 new BackgroundTracingReactiveConfig()); |
330 | 468 |
331 bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario( | 469 bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario( |
332 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 470 config.Pass(), upload_config_wrapper.get_receive_callback(), |
471 base::Closure(), false); | |
333 | 472 |
334 EXPECT_FALSE(result); | 473 EXPECT_FALSE(result); |
335 } | 474 } |
336 } | 475 } |
337 | 476 |
338 } // namespace content | 477 } // namespace content |
OLD | NEW |