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 kOutputBufferLength = 10 * 1024 * 1024; |
| 41 std::vector<char> output_str(kOutputBufferLength); |
| 42 |
| 43 z_stream stream = {0}; |
| 44 stream.avail_in = compressed_length; |
| 45 stream.avail_out = kOutputBufferLength; |
| 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 = kOutputBufferLength - 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 27 matching lines...) Expand all Loading... |
90 return config.Pass(); | 119 return config.Pass(); |
91 } | 120 } |
92 | 121 |
93 void SetupBackgroundTracingManager() { | 122 void SetupBackgroundTracingManager() { |
94 content::BackgroundTracingManager::GetInstance() | 123 content::BackgroundTracingManager::GetInstance() |
95 ->InvalidateTriggerHandlesForTesting(); | 124 ->InvalidateTriggerHandlesForTesting(); |
96 } | 125 } |
97 | 126 |
98 void DisableScenarioWhenIdle() { | 127 void DisableScenarioWhenIdle() { |
99 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 128 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
100 NULL, BackgroundTracingManager::ReceiveCallback(), false); | 129 NULL, BackgroundTracingManager::ReceiveCallback(), |
| 130 BackgroundTracingManager::NO_DATA_FILTERING); |
101 } | 131 } |
102 | 132 |
103 // This tests that the endpoint receives the final trace data. | 133 // This tests that the endpoint receives the final trace data. |
104 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, | 134 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
105 ReceiveTraceFinalContentsOnTrigger) { | 135 ReceiveTraceFinalContentsOnTrigger) { |
106 { | 136 { |
107 SetupBackgroundTracingManager(); | 137 SetupBackgroundTracingManager(); |
108 | 138 |
109 base::RunLoop run_loop; | 139 base::RunLoop run_loop; |
110 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( | 140 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
111 run_loop.QuitClosure()); | 141 run_loop.QuitClosure()); |
112 | 142 |
113 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | 143 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
114 CreatePreemptiveConfig(); | 144 CreatePreemptiveConfig(); |
115 | 145 |
116 BackgroundTracingManager::TriggerHandle handle = | 146 BackgroundTracingManager::TriggerHandle handle = |
117 BackgroundTracingManager:: | 147 BackgroundTracingManager:: |
118 GetInstance()->RegisterTriggerType("preemptive_test"); | 148 GetInstance()->RegisterTriggerType("preemptive_test"); |
119 | 149 |
120 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 150 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
121 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 151 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 152 BackgroundTracingManager::NO_DATA_FILTERING); |
122 | 153 |
123 BackgroundTracingManager::GetInstance()->WhenIdle( | 154 BackgroundTracingManager::GetInstance()->WhenIdle( |
124 base::Bind(&DisableScenarioWhenIdle)); | 155 base::Bind(&DisableScenarioWhenIdle)); |
125 | 156 |
126 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 157 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
127 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 158 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
128 | 159 |
129 run_loop.Run(); | 160 run_loop.Run(); |
130 | 161 |
131 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); | 162 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); |
(...skipping 11 matching lines...) Expand all Loading... |
143 run_loop.QuitClosure()); | 174 run_loop.QuitClosure()); |
144 | 175 |
145 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | 176 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
146 CreatePreemptiveConfig(); | 177 CreatePreemptiveConfig(); |
147 | 178 |
148 content::BackgroundTracingManager::TriggerHandle handle = | 179 content::BackgroundTracingManager::TriggerHandle handle = |
149 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( | 180 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
150 "preemptive_test"); | 181 "preemptive_test"); |
151 | 182 |
152 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 183 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
153 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 184 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 185 BackgroundTracingManager::NO_DATA_FILTERING); |
154 | 186 |
155 BackgroundTracingManager::GetInstance()->WhenIdle( | 187 BackgroundTracingManager::GetInstance()->WhenIdle( |
156 base::Bind(&DisableScenarioWhenIdle)); | 188 base::Bind(&DisableScenarioWhenIdle)); |
157 | 189 |
158 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 190 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
159 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 191 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
160 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 192 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
161 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false)); | 193 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false)); |
162 | 194 |
163 run_loop.Run(); | 195 run_loop.Run(); |
164 | 196 |
165 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); | 197 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); |
166 } | 198 } |
167 } | 199 } |
168 | 200 |
| 201 namespace { |
| 202 |
| 203 bool IsTraceEventArgsWhitelisted(const char* category_group_name, |
| 204 const char* event_name) { |
| 205 if (MatchPattern(category_group_name, "benchmark") && |
| 206 MatchPattern(event_name, "whitelisted")) { |
| 207 return true; |
| 208 } |
| 209 |
| 210 return false; |
| 211 } |
| 212 |
| 213 } // namespace |
| 214 |
| 215 // This tests that non-whitelisted args get stripped if required. |
| 216 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
| 217 NoWhitelistedArgsStripped) { |
| 218 SetupBackgroundTracingManager(); |
| 219 |
| 220 base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate( |
| 221 base::Bind(&IsTraceEventArgsWhitelisted)); |
| 222 |
| 223 base::RunLoop wait_for_upload; |
| 224 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
| 225 wait_for_upload.QuitClosure()); |
| 226 |
| 227 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
| 228 CreatePreemptiveConfig(); |
| 229 |
| 230 content::BackgroundTracingManager::TriggerHandle handle = |
| 231 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
| 232 "preemptive_test"); |
| 233 |
| 234 base::RunLoop wait_for_activated; |
| 235 BackgroundTracingManager::GetInstance()->SetTracingEnabledCallbackForTesting( |
| 236 wait_for_activated.QuitClosure()); |
| 237 EXPECT_TRUE(BackgroundTracingManager::GetInstance()->SetActiveScenario( |
| 238 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 239 BackgroundTracingManager::ANONYMIZE_DATA)); |
| 240 |
| 241 wait_for_activated.Run(); |
| 242 |
| 243 TRACE_EVENT1("benchmark", "whitelisted", "find_this", 1); |
| 244 TRACE_EVENT1("benchmark", "not_whitelisted", "this_not_found", 1); |
| 245 |
| 246 BackgroundTracingManager::GetInstance()->WhenIdle( |
| 247 base::Bind(&DisableScenarioWhenIdle)); |
| 248 |
| 249 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
| 250 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
| 251 |
| 252 wait_for_upload.Run(); |
| 253 |
| 254 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); |
| 255 EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("{")); |
| 256 EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("find_this")); |
| 257 EXPECT_TRUE(!upload_config_wrapper.TraceHasMatchingString("this_not_found")); |
| 258 } |
| 259 |
| 260 // This tests subprocesses (like a navigating renderer) which gets told to |
| 261 // provide a argument-filtered trace and has no predicate in place to do the |
| 262 // filtering (in this case, only the browser process gets it set), will crash |
| 263 // rather than return potential PII. |
| 264 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
| 265 CrashWhenSubprocessWithoutArgumentFilter) { |
| 266 SetupBackgroundTracingManager(); |
| 267 |
| 268 base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate( |
| 269 base::Bind(&IsTraceEventArgsWhitelisted)); |
| 270 |
| 271 base::RunLoop wait_for_upload; |
| 272 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
| 273 wait_for_upload.QuitClosure()); |
| 274 |
| 275 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
| 276 CreatePreemptiveConfig(); |
| 277 |
| 278 content::BackgroundTracingManager::TriggerHandle handle = |
| 279 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
| 280 "preemptive_test"); |
| 281 |
| 282 base::RunLoop wait_for_activated; |
| 283 BackgroundTracingManager::GetInstance()->SetTracingEnabledCallbackForTesting( |
| 284 wait_for_activated.QuitClosure()); |
| 285 EXPECT_TRUE(BackgroundTracingManager::GetInstance()->SetActiveScenario( |
| 286 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 287 BackgroundTracingManager::ANONYMIZE_DATA)); |
| 288 |
| 289 wait_for_activated.Run(); |
| 290 |
| 291 NavigateToURL(shell(), GetTestUrl("", "about:blank")); |
| 292 |
| 293 BackgroundTracingManager::GetInstance()->WhenIdle( |
| 294 base::Bind(&DisableScenarioWhenIdle)); |
| 295 |
| 296 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
| 297 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
| 298 |
| 299 wait_for_upload.Run(); |
| 300 |
| 301 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); |
| 302 // We should *not* receive anything at all from the renderer, |
| 303 // the process should've crashed rather than letting that happen. |
| 304 EXPECT_TRUE(!upload_config_wrapper.TraceHasMatchingString("CrRendererMain")); |
| 305 } |
| 306 |
169 // This tests multiple triggers still only gathers once. | 307 // This tests multiple triggers still only gathers once. |
170 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, | 308 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
171 CallMultipleTriggersOnlyGatherOnce) { | 309 CallMultipleTriggersOnlyGatherOnce) { |
172 { | 310 { |
173 SetupBackgroundTracingManager(); | 311 SetupBackgroundTracingManager(); |
174 | 312 |
175 base::RunLoop run_loop; | 313 base::RunLoop run_loop; |
176 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( | 314 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
177 run_loop.QuitClosure()); | 315 run_loop.QuitClosure()); |
178 | 316 |
179 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | 317 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
180 CreatePreemptiveConfig(); | 318 CreatePreemptiveConfig(); |
181 | 319 |
182 BackgroundTracingPreemptiveConfig::MonitoringRule rule; | 320 BackgroundTracingPreemptiveConfig::MonitoringRule rule; |
183 rule.type = | 321 rule.type = |
184 BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED; | 322 BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED; |
185 rule.named_trigger_info.trigger_name = "test1"; | 323 rule.named_trigger_info.trigger_name = "test1"; |
186 config->configs.push_back(rule); | 324 config->configs.push_back(rule); |
187 | 325 |
188 rule.named_trigger_info.trigger_name = "test2"; | 326 rule.named_trigger_info.trigger_name = "test2"; |
189 config->configs.push_back(rule); | 327 config->configs.push_back(rule); |
190 | 328 |
191 BackgroundTracingManager::TriggerHandle handle1 = | 329 BackgroundTracingManager::TriggerHandle handle1 = |
192 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test1"); | 330 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test1"); |
193 BackgroundTracingManager::TriggerHandle handle2 = | 331 BackgroundTracingManager::TriggerHandle handle2 = |
194 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test2"); | 332 BackgroundTracingManager::GetInstance()->RegisterTriggerType("test2"); |
195 | 333 |
196 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 334 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
197 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 335 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 336 BackgroundTracingManager::NO_DATA_FILTERING); |
198 | 337 |
199 BackgroundTracingManager::GetInstance()->WhenIdle( | 338 BackgroundTracingManager::GetInstance()->WhenIdle( |
200 base::Bind(&DisableScenarioWhenIdle)); | 339 base::Bind(&DisableScenarioWhenIdle)); |
201 | 340 |
202 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 341 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
203 handle1, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 342 handle1, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
204 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 343 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
205 handle2, | 344 handle2, |
206 base::Bind(&StartedFinalizingCallback, base::Closure(), false)); | 345 base::Bind(&StartedFinalizingCallback, base::Closure(), false)); |
207 | 346 |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
249 (base::Closure())); | 388 (base::Closure())); |
250 | 389 |
251 scoped_ptr<BackgroundTracingPreemptiveConfig> config = | 390 scoped_ptr<BackgroundTracingPreemptiveConfig> config = |
252 CreatePreemptiveConfig(); | 391 CreatePreemptiveConfig(); |
253 | 392 |
254 content::BackgroundTracingManager::TriggerHandle handle = | 393 content::BackgroundTracingManager::TriggerHandle handle = |
255 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( | 394 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
256 "does_not_exist"); | 395 "does_not_exist"); |
257 | 396 |
258 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 397 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
259 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 398 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 399 BackgroundTracingManager::NO_DATA_FILTERING); |
260 | 400 |
261 BackgroundTracingManager::GetInstance()->WhenIdle( | 401 BackgroundTracingManager::GetInstance()->WhenIdle( |
262 base::Bind(&DisableScenarioWhenIdle)); | 402 base::Bind(&DisableScenarioWhenIdle)); |
263 | 403 |
264 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 404 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
265 handle, | 405 handle, |
266 base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false)); | 406 base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false)); |
267 | 407 |
268 run_loop.Run(); | 408 run_loop.Run(); |
269 | 409 |
(...skipping 15 matching lines...) Expand all Loading... |
285 CreatePreemptiveConfig(); | 425 CreatePreemptiveConfig(); |
286 | 426 |
287 content::BackgroundTracingManager::TriggerHandle handle = | 427 content::BackgroundTracingManager::TriggerHandle handle = |
288 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( | 428 content::BackgroundTracingManager::GetInstance()->RegisterTriggerType( |
289 "preemptive_test"); | 429 "preemptive_test"); |
290 | 430 |
291 content::BackgroundTracingManager::GetInstance() | 431 content::BackgroundTracingManager::GetInstance() |
292 ->InvalidateTriggerHandlesForTesting(); | 432 ->InvalidateTriggerHandlesForTesting(); |
293 | 433 |
294 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 434 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
295 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 435 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 436 BackgroundTracingManager::NO_DATA_FILTERING); |
296 | 437 |
297 BackgroundTracingManager::GetInstance()->WhenIdle( | 438 BackgroundTracingManager::GetInstance()->WhenIdle( |
298 base::Bind(&DisableScenarioWhenIdle)); | 439 base::Bind(&DisableScenarioWhenIdle)); |
299 | 440 |
300 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 441 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
301 handle, | 442 handle, |
302 base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false)); | 443 base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false)); |
303 | 444 |
304 run_loop.Run(); | 445 run_loop.Run(); |
305 | 446 |
(...skipping 14 matching lines...) Expand all Loading... |
320 new content::BackgroundTracingPreemptiveConfig()); | 461 new content::BackgroundTracingPreemptiveConfig()); |
321 | 462 |
322 BackgroundTracingPreemptiveConfig::MonitoringRule rule; | 463 BackgroundTracingPreemptiveConfig::MonitoringRule rule; |
323 rule.type = BackgroundTracingPreemptiveConfig:: | 464 rule.type = BackgroundTracingPreemptiveConfig:: |
324 MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE; | 465 MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE; |
325 rule.histogram_trigger_info.histogram_name_to_trigger_on = "fake"; | 466 rule.histogram_trigger_info.histogram_name_to_trigger_on = "fake"; |
326 rule.histogram_trigger_info.histogram_bin_to_trigger_on = 0; | 467 rule.histogram_trigger_info.histogram_bin_to_trigger_on = 0; |
327 config->configs.push_back(rule); | 468 config->configs.push_back(rule); |
328 | 469 |
329 bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario( | 470 bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario( |
330 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 471 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 472 BackgroundTracingManager::NO_DATA_FILTERING); |
331 | 473 |
332 EXPECT_FALSE(result); | 474 EXPECT_FALSE(result); |
333 } | 475 } |
334 } | 476 } |
335 | 477 |
336 // This tests that reactive mode records and terminates with timeout. | 478 // This tests that reactive mode records and terminates with timeout. |
337 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, | 479 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest, |
338 ReactiveTimeoutTermination) { | 480 ReactiveTimeoutTermination) { |
339 { | 481 { |
340 SetupBackgroundTracingManager(); | 482 SetupBackgroundTracingManager(); |
341 | 483 |
342 base::RunLoop run_loop; | 484 base::RunLoop run_loop; |
343 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( | 485 BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper( |
344 run_loop.QuitClosure()); | 486 run_loop.QuitClosure()); |
345 | 487 |
346 scoped_ptr<BackgroundTracingReactiveConfig> config = | 488 scoped_ptr<BackgroundTracingReactiveConfig> config = |
347 CreateReactiveConfig(); | 489 CreateReactiveConfig(); |
348 | 490 |
349 BackgroundTracingManager::TriggerHandle handle = | 491 BackgroundTracingManager::TriggerHandle handle = |
350 BackgroundTracingManager:: | 492 BackgroundTracingManager:: |
351 GetInstance()->RegisterTriggerType("reactive_test"); | 493 GetInstance()->RegisterTriggerType("reactive_test"); |
352 | 494 |
353 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 495 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
354 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 496 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 497 BackgroundTracingManager::NO_DATA_FILTERING); |
355 | 498 |
356 BackgroundTracingManager::GetInstance()->WhenIdle( | 499 BackgroundTracingManager::GetInstance()->WhenIdle( |
357 base::Bind(&DisableScenarioWhenIdle)); | 500 base::Bind(&DisableScenarioWhenIdle)); |
358 | 501 |
359 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 502 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
360 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 503 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
361 | 504 |
362 BackgroundTracingManager::GetInstance()->FireTimerForTesting(); | 505 BackgroundTracingManager::GetInstance()->FireTimerForTesting(); |
363 | 506 |
364 run_loop.Run(); | 507 run_loop.Run(); |
(...skipping 13 matching lines...) Expand all Loading... |
378 run_loop.QuitClosure()); | 521 run_loop.QuitClosure()); |
379 | 522 |
380 scoped_ptr<BackgroundTracingReactiveConfig> config = | 523 scoped_ptr<BackgroundTracingReactiveConfig> config = |
381 CreateReactiveConfig(); | 524 CreateReactiveConfig(); |
382 | 525 |
383 BackgroundTracingManager::TriggerHandle handle = | 526 BackgroundTracingManager::TriggerHandle handle = |
384 BackgroundTracingManager:: | 527 BackgroundTracingManager:: |
385 GetInstance()->RegisterTriggerType("reactive_test"); | 528 GetInstance()->RegisterTriggerType("reactive_test"); |
386 | 529 |
387 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 530 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
388 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 531 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 532 BackgroundTracingManager::NO_DATA_FILTERING); |
389 | 533 |
390 BackgroundTracingManager::GetInstance()->WhenIdle( | 534 BackgroundTracingManager::GetInstance()->WhenIdle( |
391 base::Bind(&DisableScenarioWhenIdle)); | 535 base::Bind(&DisableScenarioWhenIdle)); |
392 | 536 |
393 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 537 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
394 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 538 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
395 // second trigger to terminate. | 539 // second trigger to terminate. |
396 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 540 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
397 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 541 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
398 | 542 |
(...skipping 14 matching lines...) Expand all Loading... |
413 run_loop.QuitClosure()); | 557 run_loop.QuitClosure()); |
414 | 558 |
415 scoped_ptr<BackgroundTracingReactiveConfig> config = | 559 scoped_ptr<BackgroundTracingReactiveConfig> config = |
416 CreateReactiveConfig(); | 560 CreateReactiveConfig(); |
417 | 561 |
418 BackgroundTracingManager::TriggerHandle handle = | 562 BackgroundTracingManager::TriggerHandle handle = |
419 BackgroundTracingManager:: | 563 BackgroundTracingManager:: |
420 GetInstance()->RegisterTriggerType("reactive_test"); | 564 GetInstance()->RegisterTriggerType("reactive_test"); |
421 | 565 |
422 BackgroundTracingManager::GetInstance()->SetActiveScenario( | 566 BackgroundTracingManager::GetInstance()->SetActiveScenario( |
423 config.Pass(), upload_config_wrapper.get_receive_callback(), true); | 567 config.Pass(), upload_config_wrapper.get_receive_callback(), |
| 568 BackgroundTracingManager::NO_DATA_FILTERING); |
424 | 569 |
425 BackgroundTracingManager::GetInstance()->WhenIdle( | 570 BackgroundTracingManager::GetInstance()->WhenIdle( |
426 base::Bind(&DisableScenarioWhenIdle)); | 571 base::Bind(&DisableScenarioWhenIdle)); |
427 | 572 |
428 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 573 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
429 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 574 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
430 // second trigger to terminate. | 575 // second trigger to terminate. |
431 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 576 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
432 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); | 577 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true)); |
433 // third trigger to trigger again, fails as it is still gathering. | 578 // third trigger to trigger again, fails as it is still gathering. |
434 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( | 579 BackgroundTracingManager::GetInstance()->TriggerNamedEvent( |
435 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false)); | 580 handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false)); |
436 | 581 |
437 run_loop.Run(); | 582 run_loop.Run(); |
438 | 583 |
439 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); | 584 EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1); |
440 } | 585 } |
441 } | 586 } |
442 | 587 |
443 } // namespace content | 588 } // namespace content |
OLD | NEW |