base/tracked_objects_unittest.cc

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