1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 // Test of classes in the tracked_objects.h classes. 6 7 #include "base/tracked_objects.h" 8 9 #include "base/memory/scoped_ptr.h" 10 #include "base/process/process_handle.h" 11 #include "base/time/time.h" 12 #include "testing/gtest/include/gtest/gtest.h" 13 14 const int kLineNumber = 1776; 15 const char kFile[] = "FixedUnitTestFileName"; 16 const char kWorkerThreadName[] = "WorkerThread-1"; 17 const char kMainThreadName[] = "SomeMainThreadName"; 18 const char kStillAlive[] = "Still_Alive"; 19 20 namespace tracked_objects { 21 22 class TrackedObjectsTest : public testing::Test { 23 protected: 24 TrackedObjectsTest() { 25 // On entry, leak any database structures in case they are still in use by 26 // prior threads. 27 ThreadData::ShutdownSingleThreadedCleanup(true); 28 } 29 30 virtual ~TrackedObjectsTest() { 31 // We should not need to leak any structures we create, since we are 32 // single threaded, and carefully accounting for items. 33 ThreadData::ShutdownSingleThreadedCleanup(false); 34 } 35 36 // Reset the profiler state. 37 void Reset() { 38 ThreadData::ShutdownSingleThreadedCleanup(false); 39 } 40 41 // Simulate a birth on the thread named |thread_name|, at the given 42 // |location|. 43 void TallyABirth(const Location& location, const std::string& thread_name) { 44 // If the |thread_name| is empty, we don't initialize system with a thread 45 // name, so we're viewed as a worker thread. 46 if (!thread_name.empty()) 47 ThreadData::InitializeThreadContext(kMainThreadName); 48 49 // Do not delete |birth|. We don't own it. 50 Births* birth = ThreadData::TallyABirthIfActive(location); 51 52 if (ThreadData::status() == ThreadData::DEACTIVATED) 53 EXPECT_EQ(reinterpret_cast<Births*>(NULL), birth); 54 else 55 EXPECT_NE(reinterpret_cast<Births*>(NULL), birth); 56 } 57 58 // Helper function to verify the most common test expectations. 59 void ExpectSimpleProcessData(const ProcessDataSnapshot& process_data, 60 const std::string& function_name, 61 const std::string& birth_thread, 62 const std::string& death_thread, 63 int count, 64 int run_ms, 65 int queue_ms) { 66 ASSERT_EQ(1u, process_data.tasks.size()); 67 68 EXPECT_EQ(kFile, process_data.tasks[0].birth.location.file_name); 69 EXPECT_EQ(function_name, 70 process_data.tasks[0].birth.location.function_name); 71 EXPECT_EQ(kLineNumber, process_data.tasks[0].birth.location.line_number); 72 73 EXPECT_EQ(birth_thread, process_data.tasks[0].birth.thread_name); 74 75 EXPECT_EQ(count, process_data.tasks[0].death_data.count); 76 EXPECT_EQ(count * run_ms, 77 process_data.tasks[0].death_data.run_duration_sum); 78 EXPECT_EQ(run_ms, process_data.tasks[0].death_data.run_duration_max); 79 EXPECT_EQ(run_ms, process_data.tasks[0].death_data.run_duration_sample); 80 EXPECT_EQ(count * queue_ms, 81 process_data.tasks[0].death_data.queue_duration_sum); 82 EXPECT_EQ(queue_ms, process_data.tasks[0].death_data.queue_duration_max); 83 EXPECT_EQ(queue_ms, process_data.tasks[0].death_data.queue_duration_sample); 84 85 EXPECT_EQ(death_thread, process_data.tasks[0].death_thread_name); 86 87 EXPECT_EQ(0u, process_data.descendants.size()); 88 89 EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id); 90 } 91 }; 92 93 TEST_F(TrackedObjectsTest, MinimalStartupShutdown) { 94 // Minimal test doesn't even create any tasks. 95 if (!ThreadData::InitializeAndSetTrackingStatus( 96 ThreadData::PROFILING_CHILDREN_ACTIVE)) 97 return; 98 99 EXPECT_FALSE(ThreadData::first()); // No activity even on this thread. 100 ThreadData* data = ThreadData::Get(); 101 EXPECT_TRUE(ThreadData::first()); // Now class was constructed. 102 ASSERT_TRUE(data); 103 EXPECT_FALSE(data->next()); 104 EXPECT_EQ(data, ThreadData::Get()); 105 ThreadData::BirthMap birth_map; 106 ThreadData::DeathMap death_map; 107 ThreadData::ParentChildSet parent_child_set; 108 data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set); 109 EXPECT_EQ(0u, birth_map.size()); 110 EXPECT_EQ(0u, death_map.size()); 111 EXPECT_EQ(0u, parent_child_set.size()); 112 113 // Clean up with no leaking. 114 Reset(); 115 116 // Do it again, just to be sure we reset state completely. 117 EXPECT_TRUE(ThreadData::InitializeAndSetTrackingStatus( 118 ThreadData::PROFILING_CHILDREN_ACTIVE)); 119 EXPECT_FALSE(ThreadData::first()); // No activity even on this thread. 120 data = ThreadData::Get(); 121 EXPECT_TRUE(ThreadData::first()); // Now class was constructed. 122 ASSERT_TRUE(data); 123 EXPECT_FALSE(data->next()); 124 EXPECT_EQ(data, ThreadData::Get()); 125 birth_map.clear(); 126 death_map.clear(); 127 parent_child_set.clear(); 128 data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set); 129 EXPECT_EQ(0u, birth_map.size()); 130 EXPECT_EQ(0u, death_map.size()); 131 EXPECT_EQ(0u, parent_child_set.size()); 132 } 133 134 TEST_F(TrackedObjectsTest, TinyStartupShutdown) { 135 if (!ThreadData::InitializeAndSetTrackingStatus( 136 ThreadData::PROFILING_CHILDREN_ACTIVE)) 137 return; 138 139 // Instigate tracking on a single tracked object, on our thread. 140 const char kFunction[] = "TinyStartupShutdown"; 141 Location location(kFunction, kFile, kLineNumber, NULL); 142 Births* first_birth = ThreadData::TallyABirthIfActive(location); 143 144 ThreadData* data = ThreadData::first(); 145 ASSERT_TRUE(data); 146 EXPECT_FALSE(data->next()); 147 EXPECT_EQ(data, ThreadData::Get()); 148 ThreadData::BirthMap birth_map; 149 ThreadData::DeathMap death_map; 150 ThreadData::ParentChildSet parent_child_set; 151 data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set); 152 EXPECT_EQ(1u, birth_map.size()); // 1 birth location. 153 EXPECT_EQ(1, birth_map.begin()->second->birth_count()); // 1 birth. 154 EXPECT_EQ(0u, death_map.size()); // No deaths. 155 EXPECT_EQ(0u, parent_child_set.size()); // No children. 156 157 158 // Now instigate another birth, while we are timing the run of the first 159 // execution. 160 ThreadData::NowForStartOfRun(first_birth); 161 // Create a child (using the same birth location). 162 // TrackingInfo will call TallyABirth() during construction. 163 base::TimeTicks kBogusBirthTime; 164 base::TrackingInfo pending_task(location, kBogusBirthTime); 165 TrackedTime start_time(pending_task.time_posted); 166 // Finally conclude the outer run. 167 TrackedTime end_time = ThreadData::NowForEndOfRun(); 168 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, start_time, 169 end_time); 170 171 birth_map.clear(); 172 death_map.clear(); 173 parent_child_set.clear(); 174 data->SnapshotMaps(false, &birth_map, &death_map, &parent_child_set); 175 EXPECT_EQ(1u, birth_map.size()); // 1 birth location. 176 EXPECT_EQ(2, birth_map.begin()->second->birth_count()); // 2 births. 177 EXPECT_EQ(1u, death_map.size()); // 1 location. 178 EXPECT_EQ(1, death_map.begin()->second.count()); // 1 death. 179 if (ThreadData::TrackingParentChildStatus()) { 180 EXPECT_EQ(1u, parent_child_set.size()); // 1 child. 181 EXPECT_EQ(parent_child_set.begin()->first, 182 parent_child_set.begin()->second); 183 } else { 184 EXPECT_EQ(0u, parent_child_set.size()); // no stats. 185 } 186 187 // The births were at the same location as the one known death. 188 EXPECT_EQ(birth_map.begin()->second, death_map.begin()->first); 189 190 ProcessDataSnapshot process_data; 191 ThreadData::Snapshot(false, &process_data); 192 193 const int32 time_elapsed = (end_time - start_time).InMilliseconds(); 194 ASSERT_EQ(1u, process_data.tasks.size()); 195 EXPECT_EQ(kFile, process_data.tasks[0].birth.location.file_name); 196 EXPECT_EQ(kFunction, process_data.tasks[0].birth.location.function_name); 197 EXPECT_EQ(kLineNumber, process_data.tasks[0].birth.location.line_number); 198 EXPECT_EQ(kWorkerThreadName, process_data.tasks[0].birth.thread_name); 199 EXPECT_EQ(1, process_data.tasks[0].death_data.count); 200 EXPECT_EQ(time_elapsed, process_data.tasks[0].death_data.run_duration_sum); 201 EXPECT_EQ(time_elapsed, process_data.tasks[0].death_data.run_duration_max); 202 EXPECT_EQ(time_elapsed, process_data.tasks[0].death_data.run_duration_sample); 203 EXPECT_EQ(0, process_data.tasks[0].death_data.queue_duration_sum); 204 EXPECT_EQ(0, process_data.tasks[0].death_data.queue_duration_max); 205 EXPECT_EQ(0, process_data.tasks[0].death_data.queue_duration_sample); 206 EXPECT_EQ(kWorkerThreadName, process_data.tasks[0].death_thread_name); 207 208 if (ThreadData::TrackingParentChildStatus()) { 209 ASSERT_EQ(1u, process_data.descendants.size()); 210 EXPECT_EQ(kFile, process_data.descendants[0].parent.location.file_name); 211 EXPECT_EQ(kFunction, 212 process_data.descendants[0].parent.location.function_name); 213 EXPECT_EQ(kLineNumber, 214 process_data.descendants[0].parent.location.line_number); 215 EXPECT_EQ(kWorkerThreadName, 216 process_data.descendants[0].parent.thread_name); 217 EXPECT_EQ(kFile, process_data.descendants[0].child.location.file_name); 218 EXPECT_EQ(kFunction, 219 process_data.descendants[0].child.location.function_name); 220 EXPECT_EQ(kLineNumber, 221 process_data.descendants[0].child.location.line_number); 222 EXPECT_EQ(kWorkerThreadName, process_data.descendants[0].child.thread_name); 223 } else { 224 EXPECT_EQ(0u, process_data.descendants.size()); 225 } 226 } 227 228 TEST_F(TrackedObjectsTest, DeathDataTest) { 229 if (!ThreadData::InitializeAndSetTrackingStatus( 230 ThreadData::PROFILING_CHILDREN_ACTIVE)) 231 return; 232 233 scoped_ptr<DeathData> data(new DeathData()); 234 ASSERT_NE(data, reinterpret_cast<DeathData*>(NULL)); 235 EXPECT_EQ(data->run_duration_sum(), 0); 236 EXPECT_EQ(data->run_duration_sample(), 0); 237 EXPECT_EQ(data->queue_duration_sum(), 0); 238 EXPECT_EQ(data->queue_duration_sample(), 0); 239 EXPECT_EQ(data->count(), 0); 240 241 int32 run_ms = 42; 242 int32 queue_ms = 8; 243 244 const int kUnrandomInt = 0; // Fake random int that ensure we sample data. 245 data->RecordDeath(queue_ms, run_ms, kUnrandomInt); 246 EXPECT_EQ(data->run_duration_sum(), run_ms); 247 EXPECT_EQ(data->run_duration_sample(), run_ms); 248 EXPECT_EQ(data->queue_duration_sum(), queue_ms); 249 EXPECT_EQ(data->queue_duration_sample(), queue_ms); 250 EXPECT_EQ(data->count(), 1); 251 252 data->RecordDeath(queue_ms, run_ms, kUnrandomInt); 253 EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms); 254 EXPECT_EQ(data->run_duration_sample(), run_ms); 255 EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms); 256 EXPECT_EQ(data->queue_duration_sample(), queue_ms); 257 EXPECT_EQ(data->count(), 2); 258 259 DeathDataSnapshot snapshot(*data); 260 EXPECT_EQ(2, snapshot.count); 261 EXPECT_EQ(2 * run_ms, snapshot.run_duration_sum); 262 EXPECT_EQ(run_ms, snapshot.run_duration_max); 263 EXPECT_EQ(run_ms, snapshot.run_duration_sample); 264 EXPECT_EQ(2 * queue_ms, snapshot.queue_duration_sum); 265 EXPECT_EQ(queue_ms, snapshot.queue_duration_max); 266 EXPECT_EQ(queue_ms, snapshot.queue_duration_sample); 267 } 268 269 TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotWorkerThread) { 270 // Start in the deactivated state. 271 if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED)) 272 return; 273 274 const char kFunction[] = "DeactivatedBirthOnlyToSnapshotWorkerThread"; 275 Location location(kFunction, kFile, kLineNumber, NULL); 276 TallyABirth(location, std::string()); 277 278 ProcessDataSnapshot process_data; 279 ThreadData::Snapshot(false, &process_data); 280 EXPECT_EQ(0u, process_data.tasks.size()); 281 EXPECT_EQ(0u, process_data.descendants.size()); 282 EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id); 283 } 284 285 TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotMainThread) { 286 // Start in the deactivated state. 287 if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED)) 288 return; 289 290 const char kFunction[] = "DeactivatedBirthOnlyToSnapshotMainThread"; 291 Location location(kFunction, kFile, kLineNumber, NULL); 292 TallyABirth(location, kMainThreadName); 293 294 ProcessDataSnapshot process_data; 295 ThreadData::Snapshot(false, &process_data); 296 EXPECT_EQ(0u, process_data.tasks.size()); 297 EXPECT_EQ(0u, process_data.descendants.size()); 298 EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id); 299 } 300 301 TEST_F(TrackedObjectsTest, BirthOnlyToSnapshotWorkerThread) { 302 if (!ThreadData::InitializeAndSetTrackingStatus( 303 ThreadData::PROFILING_CHILDREN_ACTIVE)) 304 return; 305 306 const char kFunction[] = "BirthOnlyToSnapshotWorkerThread"; 307 Location location(kFunction, kFile, kLineNumber, NULL); 308 TallyABirth(location, std::string()); 309 310 ProcessDataSnapshot process_data; 311 ThreadData::Snapshot(false, &process_data); 312 ExpectSimpleProcessData(process_data, kFunction, kWorkerThreadName, 313 kStillAlive, 1, 0, 0); 314 } 315 316 TEST_F(TrackedObjectsTest, BirthOnlyToSnapshotMainThread) { 317 if (!ThreadData::InitializeAndSetTrackingStatus( 318 ThreadData::PROFILING_CHILDREN_ACTIVE)) 319 return; 320 321 const char kFunction[] = "BirthOnlyToSnapshotMainThread"; 322 Location location(kFunction, kFile, kLineNumber, NULL); 323 TallyABirth(location, kMainThreadName); 324 325 ProcessDataSnapshot process_data; 326 ThreadData::Snapshot(false, &process_data); 327 ExpectSimpleProcessData(process_data, kFunction, kMainThreadName, kStillAlive, 328 1, 0, 0); 329 } 330 331 TEST_F(TrackedObjectsTest, LifeCycleToSnapshotMainThread) { 332 if (!ThreadData::InitializeAndSetTrackingStatus( 333 ThreadData::PROFILING_CHILDREN_ACTIVE)) 334 return; 335 336 const char kFunction[] = "LifeCycleToSnapshotMainThread"; 337 Location location(kFunction, kFile, kLineNumber, NULL); 338 TallyABirth(location, kMainThreadName); 339 340 const base::TimeTicks kTimePosted = base::TimeTicks() + 341 base::TimeDelta::FromMilliseconds(1); 342 const base::TimeTicks kDelayedStartTime = base::TimeTicks(); 343 // TrackingInfo will call TallyABirth() during construction. 344 base::TrackingInfo pending_task(location, kDelayedStartTime); 345 pending_task.time_posted = kTimePosted; // Overwrite implied Now(). 346 347 const TrackedTime kStartOfRun = TrackedTime() + 348 Duration::FromMilliseconds(5); 349 const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7); 350 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, 351 kStartOfRun, kEndOfRun); 352 353 ProcessDataSnapshot process_data; 354 ThreadData::Snapshot(false, &process_data); 355 ExpectSimpleProcessData(process_data, kFunction, kMainThreadName, 356 kMainThreadName, 1, 2, 4); 357 } 358 359 // We will deactivate tracking after the birth, and before the death, and 360 // demonstrate that the lifecycle is completely tallied. This ensures that 361 // our tallied births are matched by tallied deaths (except for when the 362 // task is still running, or is queued). 363 TEST_F(TrackedObjectsTest, LifeCycleMidDeactivatedToSnapshotMainThread) { 364 if (!ThreadData::InitializeAndSetTrackingStatus( 365 ThreadData::PROFILING_CHILDREN_ACTIVE)) 366 return; 367 368 const char kFunction[] = "LifeCycleMidDeactivatedToSnapshotMainThread"; 369 Location location(kFunction, kFile, kLineNumber, NULL); 370 TallyABirth(location, kMainThreadName); 371 372 const base::TimeTicks kTimePosted = base::TimeTicks() + 373 base::TimeDelta::FromMilliseconds(1); 374 const base::TimeTicks kDelayedStartTime = base::TimeTicks(); 375 // TrackingInfo will call TallyABirth() during construction. 376 base::TrackingInfo pending_task(location, kDelayedStartTime); 377 pending_task.time_posted = kTimePosted; // Overwrite implied Now(). 378 379 // Turn off tracking now that we have births. 380 EXPECT_TRUE(ThreadData::InitializeAndSetTrackingStatus( 381 ThreadData::DEACTIVATED)); 382 383 const TrackedTime kStartOfRun = TrackedTime() + 384 Duration::FromMilliseconds(5); 385 const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7); 386 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, 387 kStartOfRun, kEndOfRun); 388 389 ProcessDataSnapshot process_data; 390 ThreadData::Snapshot(false, &process_data); 391 ExpectSimpleProcessData(process_data, kFunction, kMainThreadName, 392 kMainThreadName, 1, 2, 4); 393 } 394 395 // We will deactivate tracking before starting a life cycle, and neither 396 // the birth nor the death will be recorded. 397 TEST_F(TrackedObjectsTest, LifeCyclePreDeactivatedToSnapshotMainThread) { 398 // Start in the deactivated state. 399 if (!ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED)) 400 return; 401 402 const char kFunction[] = "LifeCyclePreDeactivatedToSnapshotMainThread"; 403 Location location(kFunction, kFile, kLineNumber, NULL); 404 TallyABirth(location, kMainThreadName); 405 406 const base::TimeTicks kTimePosted = base::TimeTicks() + 407 base::TimeDelta::FromMilliseconds(1); 408 const base::TimeTicks kDelayedStartTime = base::TimeTicks(); 409 // TrackingInfo will call TallyABirth() during construction. 410 base::TrackingInfo pending_task(location, kDelayedStartTime); 411 pending_task.time_posted = kTimePosted; // Overwrite implied Now(). 412 413 const TrackedTime kStartOfRun = TrackedTime() + 414 Duration::FromMilliseconds(5); 415 const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7); 416 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, 417 kStartOfRun, kEndOfRun); 418 419 ProcessDataSnapshot process_data; 420 ThreadData::Snapshot(false, &process_data); 421 EXPECT_EQ(0u, process_data.tasks.size()); 422 EXPECT_EQ(0u, process_data.descendants.size()); 423 EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id); 424 } 425 426 TEST_F(TrackedObjectsTest, LifeCycleToSnapshotWorkerThread) { 427 if (!ThreadData::InitializeAndSetTrackingStatus( 428 ThreadData::PROFILING_CHILDREN_ACTIVE)) 429 return; 430 431 const char kFunction[] = "LifeCycleToSnapshotWorkerThread"; 432 Location location(kFunction, kFile, kLineNumber, NULL); 433 // Do not delete |birth|. We don't own it. 434 Births* birth = ThreadData::TallyABirthIfActive(location); 435 EXPECT_NE(reinterpret_cast<Births*>(NULL), birth); 436 437 const TrackedTime kTimePosted = TrackedTime() + Duration::FromMilliseconds(1); 438 const TrackedTime kStartOfRun = TrackedTime() + 439 Duration::FromMilliseconds(5); 440 const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7); 441 ThreadData::TallyRunOnWorkerThreadIfTracking(birth, kTimePosted, 442 kStartOfRun, kEndOfRun); 443 444 // Call for the ToSnapshot, but tell it to not reset the maxes after scanning. 445 ProcessDataSnapshot process_data; 446 ThreadData::Snapshot(false, &process_data); 447 ExpectSimpleProcessData(process_data, kFunction, kWorkerThreadName, 448 kWorkerThreadName, 1, 2, 4); 449 450 // Call for the ToSnapshot, but tell it to reset the maxes after scanning. 451 // We'll still get the same values, but the data will be reset (which we'll 452 // see in a moment). 453 ProcessDataSnapshot process_data_pre_reset; 454 ThreadData::Snapshot(true, &process_data_pre_reset); 455 ExpectSimpleProcessData(process_data, kFunction, kWorkerThreadName, 456 kWorkerThreadName, 1, 2, 4); 457 458 // Call for the ToSnapshot, and now we'll see the result of the last 459 // translation, as the max will have been pushed back to zero. 460 ProcessDataSnapshot process_data_post_reset; 461 ThreadData::Snapshot(true, &process_data_post_reset); 462 ASSERT_EQ(1u, process_data_post_reset.tasks.size()); 463 EXPECT_EQ(kFile, process_data_post_reset.tasks[0].birth.location.file_name); 464 EXPECT_EQ(kFunction, 465 process_data_post_reset.tasks[0].birth.location.function_name); 466 EXPECT_EQ(kLineNumber, 467 process_data_post_reset.tasks[0].birth.location.line_number); 468 EXPECT_EQ(kWorkerThreadName, 469 process_data_post_reset.tasks[0].birth.thread_name); 470 EXPECT_EQ(1, process_data_post_reset.tasks[0].death_data.count); 471 EXPECT_EQ(2, process_data_post_reset.tasks[0].death_data.run_duration_sum); 472 EXPECT_EQ(0, process_data_post_reset.tasks[0].death_data.run_duration_max); 473 EXPECT_EQ(2, process_data_post_reset.tasks[0].death_data.run_duration_sample); 474 EXPECT_EQ(4, process_data_post_reset.tasks[0].death_data.queue_duration_sum); 475 EXPECT_EQ(0, process_data_post_reset.tasks[0].death_data.queue_duration_max); 476 EXPECT_EQ(4, 477 process_data_post_reset.tasks[0].death_data.queue_duration_sample); 478 EXPECT_EQ(kWorkerThreadName, 479 process_data_post_reset.tasks[0].death_thread_name); 480 EXPECT_EQ(0u, process_data_post_reset.descendants.size()); 481 EXPECT_EQ(base::GetCurrentProcId(), process_data_post_reset.process_id); 482 } 483 484 TEST_F(TrackedObjectsTest, TwoLives) { 485 if (!ThreadData::InitializeAndSetTrackingStatus( 486 ThreadData::PROFILING_CHILDREN_ACTIVE)) 487 return; 488 489 const char kFunction[] = "TwoLives"; 490 Location location(kFunction, kFile, kLineNumber, NULL); 491 TallyABirth(location, kMainThreadName); 492 493 const base::TimeTicks kTimePosted = base::TimeTicks() + 494 base::TimeDelta::FromMilliseconds(1); 495 const base::TimeTicks kDelayedStartTime = base::TimeTicks(); 496 // TrackingInfo will call TallyABirth() during construction. 497 base::TrackingInfo pending_task(location, kDelayedStartTime); 498 pending_task.time_posted = kTimePosted; // Overwrite implied Now(). 499 500 const TrackedTime kStartOfRun = TrackedTime() + 501 Duration::FromMilliseconds(5); 502 const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7); 503 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, 504 kStartOfRun, kEndOfRun); 505 506 // TrackingInfo will call TallyABirth() during construction. 507 base::TrackingInfo pending_task2(location, kDelayedStartTime); 508 pending_task2.time_posted = kTimePosted; // Overwrite implied Now(). 509 510 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task2, 511 kStartOfRun, kEndOfRun); 512 513 ProcessDataSnapshot process_data; 514 ThreadData::Snapshot(false, &process_data); 515 ExpectSimpleProcessData(process_data, kFunction, kMainThreadName, 516 kMainThreadName, 2, 2, 4); 517 } 518 519 TEST_F(TrackedObjectsTest, DifferentLives) { 520 if (!ThreadData::InitializeAndSetTrackingStatus( 521 ThreadData::PROFILING_CHILDREN_ACTIVE)) 522 return; 523 524 // Use a well named thread. 525 ThreadData::InitializeThreadContext(kMainThreadName); 526 const char kFunction[] = "DifferentLives"; 527 Location location(kFunction, kFile, kLineNumber, NULL); 528 529 const base::TimeTicks kTimePosted = base::TimeTicks() + 530 base::TimeDelta::FromMilliseconds(1); 531 const base::TimeTicks kDelayedStartTime = base::TimeTicks(); 532 // TrackingInfo will call TallyABirth() during construction. 533 base::TrackingInfo pending_task(location, kDelayedStartTime); 534 pending_task.time_posted = kTimePosted; // Overwrite implied Now(). 535 536 const TrackedTime kStartOfRun = TrackedTime() + 537 Duration::FromMilliseconds(5); 538 const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7); 539 ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, 540 kStartOfRun, kEndOfRun); 541 542 const int kSecondFakeLineNumber = 999; 543 Location second_location(kFunction, kFile, kSecondFakeLineNumber, NULL); 544 545 // TrackingInfo will call TallyABirth() during construction. 546 base::TrackingInfo pending_task2(second_location, kDelayedStartTime); 547 pending_task2.time_posted = kTimePosted; // Overwrite implied Now(). 548 549 ProcessDataSnapshot process_data; 550 ThreadData::Snapshot(false, &process_data); 551 ASSERT_EQ(2u, process_data.tasks.size()); 552 EXPECT_EQ(kFile, process_data.tasks[0].birth.location.file_name); 553 EXPECT_EQ(kFunction, process_data.tasks[0].birth.location.function_name); 554 EXPECT_EQ(kLineNumber, process_data.tasks[0].birth.location.line_number); 555 EXPECT_EQ(kMainThreadName, process_data.tasks[0].birth.thread_name); 556 EXPECT_EQ(1, process_data.tasks[0].death_data.count); 557 EXPECT_EQ(2, process_data.tasks[0].death_data.run_duration_sum); 558 EXPECT_EQ(2, process_data.tasks[0].death_data.run_duration_max); 559 EXPECT_EQ(2, process_data.tasks[0].death_data.run_duration_sample); 560 EXPECT_EQ(4, process_data.tasks[0].death_data.queue_duration_sum); 561 EXPECT_EQ(4, process_data.tasks[0].death_data.queue_duration_max); 562 EXPECT_EQ(4, process_data.tasks[0].death_data.queue_duration_sample); 563 EXPECT_EQ(kMainThreadName, process_data.tasks[0].death_thread_name); 564 EXPECT_EQ(kFile, process_data.tasks[1].birth.location.file_name); 565 EXPECT_EQ(kFunction, process_data.tasks[1].birth.location.function_name); 566 EXPECT_EQ(kSecondFakeLineNumber, 567 process_data.tasks[1].birth.location.line_number); 568 EXPECT_EQ(kMainThreadName, process_data.tasks[1].birth.thread_name); 569 EXPECT_EQ(1, process_data.tasks[1].death_data.count); 570 EXPECT_EQ(0, process_data.tasks[1].death_data.run_duration_sum); 571 EXPECT_EQ(0, process_data.tasks[1].death_data.run_duration_max); 572 EXPECT_EQ(0, process_data.tasks[1].death_data.run_duration_sample); 573 EXPECT_EQ(0, process_data.tasks[1].death_data.queue_duration_sum); 574 EXPECT_EQ(0, process_data.tasks[1].death_data.queue_duration_max); 575 EXPECT_EQ(0, process_data.tasks[1].death_data.queue_duration_sample); 576 EXPECT_EQ(kStillAlive, process_data.tasks[1].death_thread_name); 577 EXPECT_EQ(0u, process_data.descendants.size()); 578 EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id); 579 } 580 581 } // namespace tracked_objects 582
