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/trace_event/memory_dump_manager.h" | 5 #include "base/trace_event/memory_dump_manager.h" |
6 | 6 |
7 #include "base/bind_helpers.h" | 7 #include "base/bind_helpers.h" |
8 #include "base/memory/scoped_vector.h" | 8 #include "base/memory/scoped_vector.h" |
9 #include "base/message_loop/message_loop.h" | 9 #include "base/message_loop/message_loop.h" |
10 #include "base/run_loop.h" | 10 #include "base/run_loop.h" |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
92 : dump_provider_to_register_or_unregister(nullptr), | 92 : dump_provider_to_register_or_unregister(nullptr), |
93 last_session_state_(nullptr) {} | 93 last_session_state_(nullptr) {} |
94 | 94 |
95 // Ctor used by the RespectTaskRunnerAffinity test. | 95 // Ctor used by the RespectTaskRunnerAffinity test. |
96 explicit MockDumpProvider( | 96 explicit MockDumpProvider( |
97 const scoped_refptr<SingleThreadTaskRunner>& task_runner) | 97 const scoped_refptr<SingleThreadTaskRunner>& task_runner) |
98 : last_session_state_(nullptr), task_runner_(task_runner) {} | 98 : last_session_state_(nullptr), task_runner_(task_runner) {} |
99 | 99 |
100 virtual ~MockDumpProvider() {} | 100 virtual ~MockDumpProvider() {} |
101 | 101 |
102 MOCK_METHOD1(OnMemoryDump, bool(ProcessMemoryDump* pmd)); | 102 MOCK_METHOD2(OnMemoryDump, |
| 103 bool(const MemoryDumpArgs& args, ProcessMemoryDump* pmd)); |
103 | 104 |
104 // OnMemoryDump() override for the RespectTaskRunnerAffinity test. | 105 // OnMemoryDump() override for the RespectTaskRunnerAffinity test. |
105 bool OnMemoryDump_CheckTaskRunner(ProcessMemoryDump* pmd) { | 106 bool OnMemoryDump_CheckTaskRunner(const MemoryDumpArgs& args, |
| 107 ProcessMemoryDump* pmd) { |
106 EXPECT_TRUE(task_runner_->RunsTasksOnCurrentThread()); | 108 EXPECT_TRUE(task_runner_->RunsTasksOnCurrentThread()); |
107 return true; | 109 return true; |
108 } | 110 } |
109 | 111 |
110 // OnMemoryDump() override for the SharedSessionState test. | 112 // OnMemoryDump() override for the SharedSessionState test. |
111 bool OnMemoryDump_CheckSessionState(ProcessMemoryDump* pmd) { | 113 bool OnMemoryDump_CheckSessionState(const MemoryDumpArgs& args, |
| 114 ProcessMemoryDump* pmd) { |
112 MemoryDumpSessionState* cur_session_state = pmd->session_state().get(); | 115 MemoryDumpSessionState* cur_session_state = pmd->session_state().get(); |
113 if (last_session_state_) | 116 if (last_session_state_) |
114 EXPECT_EQ(last_session_state_, cur_session_state); | 117 EXPECT_EQ(last_session_state_, cur_session_state); |
115 last_session_state_ = cur_session_state; | 118 last_session_state_ = cur_session_state; |
116 return true; | 119 return true; |
117 } | 120 } |
118 | 121 |
119 // OnMemoryDump() override for the RegisterDumperWhileDumping test. | 122 // OnMemoryDump() override for the RegisterDumperWhileDumping test. |
120 bool OnMemoryDump_RegisterExtraDumpProvider(ProcessMemoryDump* pmd) { | 123 bool OnMemoryDump_RegisterExtraDumpProvider(const MemoryDumpArgs& args, |
| 124 ProcessMemoryDump* pmd) { |
121 MemoryDumpManager::GetInstance()->RegisterDumpProvider( | 125 MemoryDumpManager::GetInstance()->RegisterDumpProvider( |
122 dump_provider_to_register_or_unregister); | 126 dump_provider_to_register_or_unregister); |
123 return true; | 127 return true; |
124 } | 128 } |
125 | 129 |
126 // OnMemoryDump() override for the UnegisterDumperWhileDumping test. | 130 // OnMemoryDump() override for the UnegisterDumperWhileDumping test. |
127 bool OnMemoryDump_UnregisterDumpProvider(ProcessMemoryDump* pmd) { | 131 bool OnMemoryDump_UnregisterDumpProvider(const MemoryDumpArgs& args, |
| 132 ProcessMemoryDump* pmd) { |
128 MemoryDumpManager::GetInstance()->UnregisterDumpProvider( | 133 MemoryDumpManager::GetInstance()->UnregisterDumpProvider( |
129 dump_provider_to_register_or_unregister); | 134 dump_provider_to_register_or_unregister); |
130 return true; | 135 return true; |
131 } | 136 } |
132 | 137 |
133 // Used by OnMemoryDump_(Un)RegisterExtraDumpProvider. | 138 // Used by OnMemoryDump_(Un)RegisterExtraDumpProvider. |
134 MemoryDumpProvider* dump_provider_to_register_or_unregister; | 139 MemoryDumpProvider* dump_provider_to_register_or_unregister; |
135 | 140 |
136 private: | 141 private: |
137 MemoryDumpSessionState* last_session_state_; | 142 MemoryDumpSessionState* last_session_state_; |
138 scoped_refptr<SingleThreadTaskRunner> task_runner_; | 143 scoped_refptr<SingleThreadTaskRunner> task_runner_; |
139 }; | 144 }; |
140 | 145 |
141 TEST_F(MemoryDumpManagerTest, SingleDumper) { | 146 TEST_F(MemoryDumpManagerTest, SingleDumper) { |
142 MockDumpProvider mdp; | 147 MockDumpProvider mdp; |
143 mdm_->RegisterDumpProvider(&mdp); | 148 mdm_->RegisterDumpProvider(&mdp); |
144 | 149 |
145 // Check that the dumper is not called if the memory category is not enabled. | 150 // Check that the dumper is not called if the memory category is not enabled. |
146 EnableTracing("foo-and-bar-but-not-memory"); | 151 EnableTracing("foo-and-bar-but-not-memory"); |
147 EXPECT_CALL(mdp, OnMemoryDump(_)).Times(0); | 152 EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0); |
148 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); | 153 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); |
149 DisableTracing(); | 154 DisableTracing(); |
150 | 155 |
151 // Now repeat enabling the memory category and check that the dumper is | 156 // Now repeat enabling the memory category and check that the dumper is |
152 // invoked this time. | 157 // invoked this time. |
153 EnableTracing(kTraceCategory); | 158 EnableTracing(kTraceCategory); |
154 EXPECT_CALL(mdp, OnMemoryDump(_)).Times(3).WillRepeatedly(Return(true)); | 159 EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(3).WillRepeatedly(Return(true)); |
155 for (int i = 0; i < 3; ++i) | 160 for (int i = 0; i < 3; ++i) |
156 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); | 161 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); |
157 DisableTracing(); | 162 DisableTracing(); |
158 | 163 |
159 mdm_->UnregisterDumpProvider(&mdp); | 164 mdm_->UnregisterDumpProvider(&mdp); |
160 | 165 |
161 // Finally check the unregister logic (no calls to the mdp after unregister). | 166 // Finally check the unregister logic (no calls to the mdp after unregister). |
162 EnableTracing(kTraceCategory); | 167 EnableTracing(kTraceCategory); |
163 EXPECT_CALL(mdp, OnMemoryDump(_)).Times(0); | 168 EXPECT_CALL(mdp, OnMemoryDump(_, _)).Times(0); |
164 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); | 169 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); |
165 TraceLog::GetInstance()->SetDisabled(); | 170 TraceLog::GetInstance()->SetDisabled(); |
166 } | 171 } |
167 | 172 |
168 TEST_F(MemoryDumpManagerTest, SharedSessionState) { | 173 TEST_F(MemoryDumpManagerTest, SharedSessionState) { |
169 MockDumpProvider mdp1; | 174 MockDumpProvider mdp1; |
170 MockDumpProvider mdp2; | 175 MockDumpProvider mdp2; |
171 mdm_->RegisterDumpProvider(&mdp1); | 176 mdm_->RegisterDumpProvider(&mdp1); |
172 mdm_->RegisterDumpProvider(&mdp2); | 177 mdm_->RegisterDumpProvider(&mdp2); |
173 | 178 |
174 EnableTracing(kTraceCategory); | 179 EnableTracing(kTraceCategory); |
175 EXPECT_CALL(mdp1, OnMemoryDump(_)) | 180 EXPECT_CALL(mdp1, OnMemoryDump(_, _)) |
176 .Times(2) | 181 .Times(2) |
177 .WillRepeatedly( | 182 .WillRepeatedly( |
178 Invoke(&mdp1, &MockDumpProvider::OnMemoryDump_CheckSessionState)); | 183 Invoke(&mdp1, &MockDumpProvider::OnMemoryDump_CheckSessionState)); |
179 EXPECT_CALL(mdp2, OnMemoryDump(_)) | 184 EXPECT_CALL(mdp2, OnMemoryDump(_, _)) |
180 .Times(2) | 185 .Times(2) |
181 .WillRepeatedly( | 186 .WillRepeatedly( |
182 Invoke(&mdp2, &MockDumpProvider::OnMemoryDump_CheckSessionState)); | 187 Invoke(&mdp2, &MockDumpProvider::OnMemoryDump_CheckSessionState)); |
183 | 188 |
184 for (int i = 0; i < 2; ++i) | 189 for (int i = 0; i < 2; ++i) |
185 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); | 190 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); |
186 | 191 |
187 DisableTracing(); | 192 DisableTracing(); |
188 } | 193 } |
189 | 194 |
190 TEST_F(MemoryDumpManagerTest, MultipleDumpers) { | 195 TEST_F(MemoryDumpManagerTest, MultipleDumpers) { |
191 MockDumpProvider mdp1; | 196 MockDumpProvider mdp1; |
192 MockDumpProvider mdp2; | 197 MockDumpProvider mdp2; |
193 | 198 |
194 // Enable only mdp1. | 199 // Enable only mdp1. |
195 mdm_->RegisterDumpProvider(&mdp1); | 200 mdm_->RegisterDumpProvider(&mdp1); |
196 EnableTracing(kTraceCategory); | 201 EnableTracing(kTraceCategory); |
197 EXPECT_CALL(mdp1, OnMemoryDump(_)).Times(1).WillRepeatedly(Return(true)); | 202 EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(1).WillRepeatedly(Return(true)); |
198 EXPECT_CALL(mdp2, OnMemoryDump(_)).Times(0); | 203 EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(0); |
199 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); | 204 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); |
200 DisableTracing(); | 205 DisableTracing(); |
201 | 206 |
202 // Invert: enable mdp1 and disable mdp2. | 207 // Invert: enable mdp1 and disable mdp2. |
203 mdm_->UnregisterDumpProvider(&mdp1); | 208 mdm_->UnregisterDumpProvider(&mdp1); |
204 mdm_->RegisterDumpProvider(&mdp2); | 209 mdm_->RegisterDumpProvider(&mdp2); |
205 EnableTracing(kTraceCategory); | 210 EnableTracing(kTraceCategory); |
206 EXPECT_CALL(mdp1, OnMemoryDump(_)).Times(0); | 211 EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(0); |
207 EXPECT_CALL(mdp2, OnMemoryDump(_)).Times(1).WillRepeatedly(Return(true)); | 212 EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(1).WillRepeatedly(Return(true)); |
208 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); | 213 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); |
209 DisableTracing(); | 214 DisableTracing(); |
210 | 215 |
211 // Enable both mdp1 and mdp2. | 216 // Enable both mdp1 and mdp2. |
212 mdm_->RegisterDumpProvider(&mdp1); | 217 mdm_->RegisterDumpProvider(&mdp1); |
213 EnableTracing(kTraceCategory); | 218 EnableTracing(kTraceCategory); |
214 EXPECT_CALL(mdp1, OnMemoryDump(_)).Times(1).WillRepeatedly(Return(true)); | 219 EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(1).WillRepeatedly(Return(true)); |
215 EXPECT_CALL(mdp2, OnMemoryDump(_)).Times(1).WillRepeatedly(Return(true)); | 220 EXPECT_CALL(mdp2, OnMemoryDump(_, _)).Times(1).WillRepeatedly(Return(true)); |
216 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); | 221 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); |
217 DisableTracing(); | 222 DisableTracing(); |
218 } | 223 } |
219 | 224 |
220 // Checks that the MemoryDumpManager respects the thread affinity when a | 225 // Checks that the MemoryDumpManager respects the thread affinity when a |
221 // MemoryDumpProvider specifies a task_runner(). The test starts creating 8 | 226 // MemoryDumpProvider specifies a task_runner(). The test starts creating 8 |
222 // threads and registering a MemoryDumpProvider on each of them. At each | 227 // threads and registering a MemoryDumpProvider on each of them. At each |
223 // iteration, one thread is removed, to check the live unregistration logic. | 228 // iteration, one thread is removed, to check the live unregistration logic. |
224 TEST_F(MemoryDumpManagerTest, RespectTaskRunnerAffinity) { | 229 TEST_F(MemoryDumpManagerTest, RespectTaskRunnerAffinity) { |
225 const uint32 kNumInitialThreads = 8; | 230 const uint32 kNumInitialThreads = 8; |
226 | 231 |
227 ScopedVector<Thread> threads; | 232 ScopedVector<Thread> threads; |
228 ScopedVector<MockDumpProvider> mdps; | 233 ScopedVector<MockDumpProvider> mdps; |
229 | 234 |
230 // Create the threads and setup the expectations. Given that at each iteration | 235 // Create the threads and setup the expectations. Given that at each iteration |
231 // we will pop out one thread/MemoryDumpProvider, each MDP is supposed to be | 236 // we will pop out one thread/MemoryDumpProvider, each MDP is supposed to be |
232 // invoked a number of times equal to its index. | 237 // invoked a number of times equal to its index. |
233 for (uint32 i = kNumInitialThreads; i > 0; --i) { | 238 for (uint32 i = kNumInitialThreads; i > 0; --i) { |
234 threads.push_back(new Thread("test thread")); | 239 threads.push_back(new Thread("test thread")); |
235 threads.back()->Start(); | 240 threads.back()->Start(); |
236 mdps.push_back(new MockDumpProvider(threads.back()->task_runner())); | 241 mdps.push_back(new MockDumpProvider(threads.back()->task_runner())); |
237 MockDumpProvider* mdp = mdps.back(); | 242 MockDumpProvider* mdp = mdps.back(); |
238 mdm_->RegisterDumpProvider(mdp, threads.back()->task_runner()); | 243 mdm_->RegisterDumpProvider(mdp, threads.back()->task_runner()); |
239 EXPECT_CALL(*mdp, OnMemoryDump(_)) | 244 EXPECT_CALL(*mdp, OnMemoryDump(_, _)) |
240 .Times(i) | 245 .Times(i) |
241 .WillRepeatedly( | 246 .WillRepeatedly( |
242 Invoke(mdp, &MockDumpProvider::OnMemoryDump_CheckTaskRunner)); | 247 Invoke(mdp, &MockDumpProvider::OnMemoryDump_CheckTaskRunner)); |
243 } | 248 } |
244 | 249 |
245 EnableTracing(kTraceCategory); | 250 EnableTracing(kTraceCategory); |
246 | 251 |
247 while (!threads.empty()) { | 252 while (!threads.empty()) { |
248 last_callback_success_ = false; | 253 last_callback_success_ = false; |
249 { | 254 { |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
281 // Enable both dump providers, make sure that mdp gets disabled after 3 failures | 286 // Enable both dump providers, make sure that mdp gets disabled after 3 failures |
282 // and not disabled after 1. | 287 // and not disabled after 1. |
283 TEST_F(MemoryDumpManagerTest, DisableFailingDumpers) { | 288 TEST_F(MemoryDumpManagerTest, DisableFailingDumpers) { |
284 MockDumpProvider mdp1; | 289 MockDumpProvider mdp1; |
285 MockDumpProvider mdp2; | 290 MockDumpProvider mdp2; |
286 | 291 |
287 mdm_->RegisterDumpProvider(&mdp1); | 292 mdm_->RegisterDumpProvider(&mdp1); |
288 mdm_->RegisterDumpProvider(&mdp2); | 293 mdm_->RegisterDumpProvider(&mdp2); |
289 EnableTracing(kTraceCategory); | 294 EnableTracing(kTraceCategory); |
290 | 295 |
291 EXPECT_CALL(mdp1, OnMemoryDump(_)) | 296 EXPECT_CALL(mdp1, OnMemoryDump(_, _)) |
292 .Times(MemoryDumpManager::kMaxConsecutiveFailuresCount) | 297 .Times(MemoryDumpManager::kMaxConsecutiveFailuresCount) |
293 .WillRepeatedly(Return(false)); | 298 .WillRepeatedly(Return(false)); |
294 | 299 |
295 EXPECT_CALL(mdp2, OnMemoryDump(_)) | 300 EXPECT_CALL(mdp2, OnMemoryDump(_, _)) |
296 .Times(1 + MemoryDumpManager::kMaxConsecutiveFailuresCount) | 301 .Times(1 + MemoryDumpManager::kMaxConsecutiveFailuresCount) |
297 .WillOnce(Return(false)) | 302 .WillOnce(Return(false)) |
298 .WillRepeatedly(Return(true)); | 303 .WillRepeatedly(Return(true)); |
299 for (int i = 0; i < 1 + MemoryDumpManager::kMaxConsecutiveFailuresCount; | 304 for (int i = 0; i < 1 + MemoryDumpManager::kMaxConsecutiveFailuresCount; |
300 i++) { | 305 i++) { |
301 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); | 306 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); |
302 } | 307 } |
303 | 308 |
304 DisableTracing(); | 309 DisableTracing(); |
305 } | 310 } |
306 | 311 |
307 // Sneakily register an extra memory dump provider while an existing one is | 312 // Sneakily register an extra memory dump provider while an existing one is |
308 // dumping and expect it to take part in the already active tracing session. | 313 // dumping and expect it to take part in the already active tracing session. |
309 TEST_F(MemoryDumpManagerTest, RegisterDumperWhileDumping) { | 314 TEST_F(MemoryDumpManagerTest, RegisterDumperWhileDumping) { |
310 MockDumpProvider mdp1; | 315 MockDumpProvider mdp1; |
311 MockDumpProvider mdp2; | 316 MockDumpProvider mdp2; |
312 | 317 |
313 mdp1.dump_provider_to_register_or_unregister = &mdp2; | 318 mdp1.dump_provider_to_register_or_unregister = &mdp2; |
314 mdm_->RegisterDumpProvider(&mdp1); | 319 mdm_->RegisterDumpProvider(&mdp1); |
315 EnableTracing(kTraceCategory); | 320 EnableTracing(kTraceCategory); |
316 | 321 |
317 EXPECT_CALL(mdp1, OnMemoryDump(_)) | 322 EXPECT_CALL(mdp1, OnMemoryDump(_, _)) |
318 .Times(4) | 323 .Times(4) |
319 .WillOnce(Return(true)) | 324 .WillOnce(Return(true)) |
320 .WillOnce(Invoke( | 325 .WillOnce(Invoke( |
321 &mdp1, &MockDumpProvider::OnMemoryDump_RegisterExtraDumpProvider)) | 326 &mdp1, &MockDumpProvider::OnMemoryDump_RegisterExtraDumpProvider)) |
322 .WillRepeatedly(Return(true)); | 327 .WillRepeatedly(Return(true)); |
323 | 328 |
324 // Depending on the insertion order (before or after mdp1), mdp2 might be | 329 // Depending on the insertion order (before or after mdp1), mdp2 might be |
325 // called also immediately after it gets registered. | 330 // called also immediately after it gets registered. |
326 EXPECT_CALL(mdp2, OnMemoryDump(_)) | 331 EXPECT_CALL(mdp2, OnMemoryDump(_, _)) |
327 .Times(Between(2, 3)) | 332 .Times(Between(2, 3)) |
328 .WillRepeatedly(Return(true)); | 333 .WillRepeatedly(Return(true)); |
329 | 334 |
330 for (int i = 0; i < 4; i++) { | 335 for (int i = 0; i < 4; i++) { |
331 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); | 336 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); |
332 } | 337 } |
333 | 338 |
334 DisableTracing(); | 339 DisableTracing(); |
335 } | 340 } |
336 | 341 |
337 // Like the above, but suddenly unregister the dump provider. | 342 // Like the above, but suddenly unregister the dump provider. |
338 TEST_F(MemoryDumpManagerTest, UnregisterDumperWhileDumping) { | 343 TEST_F(MemoryDumpManagerTest, UnregisterDumperWhileDumping) { |
339 MockDumpProvider mdp1; | 344 MockDumpProvider mdp1; |
340 MockDumpProvider mdp2; | 345 MockDumpProvider mdp2; |
341 | 346 |
342 mdm_->RegisterDumpProvider(&mdp1, ThreadTaskRunnerHandle::Get()); | 347 mdm_->RegisterDumpProvider(&mdp1, ThreadTaskRunnerHandle::Get()); |
343 mdm_->RegisterDumpProvider(&mdp2, ThreadTaskRunnerHandle::Get()); | 348 mdm_->RegisterDumpProvider(&mdp2, ThreadTaskRunnerHandle::Get()); |
344 mdp1.dump_provider_to_register_or_unregister = &mdp2; | 349 mdp1.dump_provider_to_register_or_unregister = &mdp2; |
345 EnableTracing(kTraceCategory); | 350 EnableTracing(kTraceCategory); |
346 | 351 |
347 EXPECT_CALL(mdp1, OnMemoryDump(_)) | 352 EXPECT_CALL(mdp1, OnMemoryDump(_, _)) |
348 .Times(4) | 353 .Times(4) |
349 .WillOnce(Return(true)) | 354 .WillOnce(Return(true)) |
350 .WillOnce(Invoke(&mdp1, | 355 .WillOnce( |
351 &MockDumpProvider::OnMemoryDump_UnregisterDumpProvider)) | 356 Invoke(&mdp1, &MockDumpProvider::OnMemoryDump_UnregisterDumpProvider)) |
352 .WillRepeatedly(Return(true)); | 357 .WillRepeatedly(Return(true)); |
353 | 358 |
354 // Depending on the insertion order (before or after mdp1), mdp2 might have | 359 // Depending on the insertion order (before or after mdp1), mdp2 might have |
355 // been already called when OnMemoryDump_UnregisterDumpProvider happens. | 360 // been already called when OnMemoryDump_UnregisterDumpProvider happens. |
356 EXPECT_CALL(mdp2, OnMemoryDump(_)) | 361 EXPECT_CALL(mdp2, OnMemoryDump(_, _)) |
357 .Times(Between(1, 2)) | 362 .Times(Between(1, 2)) |
358 .WillRepeatedly(Return(true)); | 363 .WillRepeatedly(Return(true)); |
359 | 364 |
360 for (int i = 0; i < 4; i++) { | 365 for (int i = 0; i < 4; i++) { |
361 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); | 366 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED); |
362 } | 367 } |
363 | 368 |
364 DisableTracing(); | 369 DisableTracing(); |
365 } | 370 } |
366 | 371 |
367 // Ensures that a NACK callback is invoked if RequestGlobalDump is called when | 372 // Ensures that a NACK callback is invoked if RequestGlobalDump is called when |
368 // tracing is not enabled. | 373 // tracing is not enabled. |
369 TEST_F(MemoryDumpManagerTest, CallbackCalledOnFailure) { | 374 TEST_F(MemoryDumpManagerTest, CallbackCalledOnFailure) { |
370 MockDumpProvider mdp1; | 375 MockDumpProvider mdp1; |
371 | 376 |
372 mdm_->RegisterDumpProvider(&mdp1); | 377 mdm_->RegisterDumpProvider(&mdp1); |
373 EXPECT_CALL(mdp1, OnMemoryDump(_)).Times(0); | 378 EXPECT_CALL(mdp1, OnMemoryDump(_, _)).Times(0); |
374 | 379 |
375 last_callback_success_ = true; | 380 last_callback_success_ = true; |
376 { | 381 { |
377 RunLoop run_loop; | 382 RunLoop run_loop; |
378 MemoryDumpCallback callback = | 383 MemoryDumpCallback callback = |
379 Bind(&MemoryDumpManagerTest::DumpCallbackAdapter, Unretained(this), | 384 Bind(&MemoryDumpManagerTest::DumpCallbackAdapter, Unretained(this), |
380 MessageLoop::current()->task_runner(), run_loop.QuitClosure()); | 385 MessageLoop::current()->task_runner(), run_loop.QuitClosure()); |
381 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED, callback); | 386 mdm_->RequestGlobalDump(MemoryDumpType::EXPLICITLY_TRIGGERED, callback); |
382 run_loop.Run(); | 387 run_loop.Run(); |
383 } | 388 } |
384 EXPECT_FALSE(last_callback_success_); | 389 EXPECT_FALSE(last_callback_success_); |
385 } | 390 } |
386 | 391 |
387 } // namespace trace_event | 392 } // namespace trace_event |
388 } // namespace base | 393 } // namespace base |
OLD | NEW |