Fully enable about:tracking by default

Support is now controlled by the flag:
--enable-tracking
and the default is always on.  To turn it off, use:
--enable-tracking=0

All profiler code is compiled now in release and official
builds (in addition to debug, where it was already active),
but most entry points can be disabled (turned into no-ops) 
by a single const bool setting atop tracked_objects.cc (in 
case folks want to revert the perf-impact of this change).

Transition to faster Now() service on Windows for the 
profiler use only.
The TimeTicks::Now() function on Window uses locking
to get a 64 bit time value.  This CL transitions 
times used for profiling to more directly use a
32 bit Time interface, which is actually what drives the
64 bit TimeTicks.  By using the smaller value, we avoid 
the need for locks, or even atomic operations for the most
part in the tracking system.  On linux, we just down-sample
the standard TimeTicks to 32 bits for consistency (clean
ability to snapshot asyncronously without atomics...
but I should verify that such is helpful to performance).

I've also put in yet more cleanup and refactoring.

r=rtenneti
bug=101856
Review URL: http://codereview.chromium.org/8391019

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@107793 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 146 insertions, 101 deletions

diff --git a/base/tracked_objects_unittest.cc b/base/tracked_objects_unittest.cc
index ef88183..15c88e8 100644
--- a/base/tracked_objects_unittest.cc
+++ b/base/tracked_objects_unittest.cc
@@ -15,15 +15,17 @@ namespace tracked_objects {
 
 class TrackedObjectsTest : public testing::Test {
  public:
-   ~TrackedObjectsTest() {
-     ThreadData::ShutdownSingleThreadedCleanup();
-   }
+  TrackedObjectsTest() {
+  }
 
+  ~TrackedObjectsTest() {
+    ThreadData::ShutdownSingleThreadedCleanup();
+  }
 };
 
 TEST_F(TrackedObjectsTest, MinimalStartupShutdown) {
   // Minimal test doesn't even create any tasks.
-  if (!ThreadData::StartTracking(true))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
@@ -41,7 +43,7 @@ TEST_F(TrackedObjectsTest, MinimalStartupShutdown) {
   ThreadData::ShutdownSingleThreadedCleanup();
 
   // Do it again, just to be sure we reset state completely.
-  ThreadData::StartTracking(true);
+  ThreadData::InitializeAndSetTrackingStatus(true);
   EXPECT_FALSE(ThreadData::first());  // No activity even on this thread.
   data = ThreadData::Get();
   EXPECT_TRUE(ThreadData::first());  // Now class was constructed.
@@ -57,7 +59,7 @@ TEST_F(TrackedObjectsTest, MinimalStartupShutdown) {
 }
 
 TEST_F(TrackedObjectsTest, TinyStartupShutdown) {
-  if (!ThreadData::StartTracking(true))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   // Instigate tracking on a single tracked object, on our thread.
@@ -77,14 +79,14 @@ TEST_F(TrackedObjectsTest, TinyStartupShutdown) {
   EXPECT_EQ(0u, death_map.size());                         // No deaths.
 
 
-  // Now instigate a birth, and a death.
-  const Births* second_birth = ThreadData::TallyABirthIfActive(location);
-  ThreadData::TallyADeathIfActive(
-      second_birth,
-      base::TimeTicks(), /* Bogus post_time. */
-      base::TimeTicks(), /* Bogus delayed_start_time. */
-      base::TimeTicks(), /* Bogus start_run_time. */
-      base::TimeTicks()  /* Bogus end_run_time */ );
+  // Now instigate another birth, and a first death at the same location.
+  // TrackingInfo will call TallyABirth() during construction.
+  base::TimeTicks kBogusStartTime;
+  MessageLoop::TrackingInfo pending_task(location, kBogusStartTime);
+  TrackedTime kBogusStartRunTime;
+  TrackedTime kBogusEndRunTime;
+  ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, kBogusStartRunTime,
+                                              kBogusEndRunTime);
 
   birth_map.clear();
   data->SnapshotBirthMap(&birth_map);
@@ -100,13 +102,13 @@ TEST_F(TrackedObjectsTest, TinyStartupShutdown) {
 }
 
 TEST_F(TrackedObjectsTest, DeathDataTest) {
-  if (!ThreadData::StartTracking(true))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   scoped_ptr<DeathData> data(new DeathData());
   ASSERT_NE(data, reinterpret_cast<DeathData*>(NULL));
-  EXPECT_EQ(data->run_duration(), base::TimeDelta());
-  EXPECT_EQ(data->queue_duration(), base::TimeDelta());
+  EXPECT_EQ(data->run_duration(), Duration());
+  EXPECT_EQ(data->queue_duration(), Duration());
   EXPECT_EQ(data->AverageMsRunDuration(), 0);
   EXPECT_EQ(data->AverageMsQueueDuration(), 0);
   EXPECT_EQ(data->count(), 0);
@@ -114,8 +116,8 @@ TEST_F(TrackedObjectsTest, DeathDataTest) {
   int run_ms = 42;
   int queue_ms = 8;
 
-  base::TimeDelta run_duration = base::TimeDelta().FromMilliseconds(run_ms);
-  base::TimeDelta queue_duration = base::TimeDelta().FromMilliseconds(queue_ms);
+  Duration run_duration = Duration().FromMilliseconds(run_ms);
+  Duration queue_duration = Duration().FromMilliseconds(queue_ms);
   data->RecordDeath(queue_duration, run_duration);
   EXPECT_EQ(data->run_duration(), run_duration);
   EXPECT_EQ(data->queue_duration(), queue_duration);
@@ -152,19 +154,18 @@ TEST_F(TrackedObjectsTest, DeathDataTest) {
 }
 
 TEST_F(TrackedObjectsTest, BirthOnlyToValueWorkerThread) {
-  if (!ThreadData::StartTracking(true))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
   // We don't initialize system with a thread name, so we're viewed as a worker
   // thread.
-  int fake_line_number = 173;
+  const int kFakeLineNumber = 173;
   const char* kFile = "FixedFileName";
   const char* kFunction = "BirthOnlyToValueWorkerThread";
-  Location location(kFunction, kFile, fake_line_number, NULL);
+  Location location(kFunction, kFile, kFakeLineNumber, NULL);
   Births* birth = ThreadData::TallyABirthIfActive(location);
   EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
 
-  int process_type = 3;
-  scoped_ptr<base::Value> value(ThreadData::ToValue(process_type));
+  scoped_ptr<base::Value> value(ThreadData::ToValue());
   std::string json;
   base::JSONWriter::Write(value.get(), false, &json);
   std::string birth_only_result = "{"
@@ -183,28 +184,26 @@ TEST_F(TrackedObjectsTest, BirthOnlyToValueWorkerThread) {
             "\"line_number\":173"
           "}"
         "}"
-      "],"
-      "\"process\":3"
+      "]"
     "}";
   EXPECT_EQ(json, birth_only_result);
 }
 
 TEST_F(TrackedObjectsTest, BirthOnlyToValueMainThread) {
-  if (!ThreadData::StartTracking(true))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext("SomeMainThreadName");
-  int fake_line_number = 173;
+  const int kFakeLineNumber = 173;
   const char* kFile = "FixedFileName";
   const char* kFunction = "BirthOnlyToValueMainThread";
-  Location location(kFunction, kFile, fake_line_number, NULL);
+  Location location(kFunction, kFile, kFakeLineNumber, NULL);
   // Do not delete birth.  We don't own it.
   Births* birth = ThreadData::TallyABirthIfActive(location);
   EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
 
-  int process_type = 34;
-  scoped_ptr<base::Value> value(ThreadData::ToValue(process_type));
+  scoped_ptr<base::Value> value(ThreadData::ToValue());
   std::string json;
   base::JSONWriter::Write(value.get(), false, &json);
   std::string birth_only_result = "{"
@@ -223,40 +222,39 @@ TEST_F(TrackedObjectsTest, BirthOnlyToValueMainThread) {
             "\"line_number\":173"
           "}"
         "}"
-      "],"
-      "\"process\":34"
+      "]"
     "}";
   EXPECT_EQ(json, birth_only_result);
 }
 
 TEST_F(TrackedObjectsTest, LifeCycleToValueMainThread) {
-  if (!ThreadData::StartTracking(true))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext("SomeMainThreadName");
-  int fake_line_number = 236;
+  const int kFakeLineNumber = 236;
   const char* kFile = "FixedFileName";
   const char* kFunction = "LifeCycleToValueMainThread";
-  Location location(kFunction, kFile, fake_line_number, NULL);
+  Location location(kFunction, kFile, kFakeLineNumber, NULL);
   // Do not delete birth.  We don't own it.
   Births* birth = ThreadData::TallyABirthIfActive(location);
   EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
 
-  // TimeTicks initializers ar ein microseconds.  Durations are calculated in
-  // milliseconds, so we need to use 1000x.
-  const base::TimeTicks time_posted = base::TimeTicks() +
-      base::TimeDelta::FromMilliseconds(1);
-  const base::TimeTicks delayed_start_time = base::TimeTicks();
-  const base::TimeTicks start_of_run = base::TimeTicks() +
-      base::TimeDelta::FromMilliseconds(5);
-  const base::TimeTicks end_of_run = base::TimeTicks() +
-      base::TimeDelta::FromMilliseconds(7);
-  ThreadData::TallyADeathIfActive(birth, time_posted, delayed_start_time,
-                                  start_of_run, end_of_run);
-
-  int process_type = 7;
-  scoped_ptr<base::Value> value(ThreadData::ToValue(process_type));
+  const base::TimeTicks kTimePosted = base::TimeTicks()
+      + base::TimeDelta::FromMilliseconds(1);
+  const base::TimeTicks kDelayedStartTime = base::TimeTicks();
+  // TrackingInfo will call TallyABirth() during construction.
+  MessageLoop::TrackingInfo pending_task(location, kDelayedStartTime);
+  pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
+
+  const TrackedTime kStartOfRun = TrackedTime() +
+      Duration::FromMilliseconds(5);
+  const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7);
+  ThreadData::TallyRunOnNamedThreadIfTracking(pending_task,
+      kStartOfRun, kEndOfRun);
+
+  scoped_ptr<base::Value> value(ThreadData::ToValue());
   std::string json;
   base::JSONWriter::Write(value.get(), false, &json);
   std::string one_line_result = "{"
@@ -275,44 +273,93 @@ TEST_F(TrackedObjectsTest, LifeCycleToValueMainThread) {
             "\"line_number\":236"
           "}"
         "}"
-      "],"
-      "\"process\":7"
+      "]"
+    "}";
+  EXPECT_EQ(json, one_line_result);
+}
+
+TEST_F(TrackedObjectsTest, LifeCycleToValueWorkerThread) {
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
+    return;
+
+  // Don't initialize thread, so that we appear as a worker thread.
+  // ThreadData::InitializeThreadContext("SomeMainThreadName");
+
+  const int kFakeLineNumber = 236;
+  const char* kFile = "FixedFileName";
+  const char* kFunction = "LifeCycleToValueWorkerThread";
+  Location location(kFunction, kFile, kFakeLineNumber, NULL);
+  // Do not delete birth.  We don't own it.
+  Births* birth = ThreadData::TallyABirthIfActive(location);
+  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
+
+  const TrackedTime kTimePosted = TrackedTime() + Duration::FromMilliseconds(1);
+  const TrackedTime kStartOfRun = TrackedTime() +
+      Duration::FromMilliseconds(5);
+  const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7);
+  ThreadData::TallyRunOnWorkerThreadIfTracking(birth, kTimePosted,
+      kStartOfRun, kEndOfRun);
+
+  scoped_ptr<base::Value> value(ThreadData::ToValue());
+  std::string json;
+  base::JSONWriter::Write(value.get(), false, &json);
+  std::string one_line_result = "{"
+      "\"list\":["
+        "{"
+          "\"birth_thread\":\"WorkerThread-1\","
+          "\"death_data\":{"
+            "\"count\":1,"
+            "\"queue_ms\":4,"
+            "\"run_ms\":2"
+          "},"
+          "\"death_thread\":\"WorkerThread-1\","
+          "\"location\":{"
+            "\"file_name\":\"FixedFileName\","
+            "\"function_name\":\"LifeCycleToValueWorkerThread\","
+            "\"line_number\":236"
+          "}"
+        "}"
+      "]"
     "}";
   EXPECT_EQ(json, one_line_result);
 }
 
 TEST_F(TrackedObjectsTest, TwoLives) {
-  if (!ThreadData::StartTracking(true))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext("SomeFileThreadName");
-  int fake_line_number = 222;
+  const int kFakeLineNumber = 222;
   const char* kFile = "AnotherFileName";
   const char* kFunction = "TwoLives";
-  Location location(kFunction, kFile, fake_line_number, NULL);
+  Location location(kFunction, kFile, kFakeLineNumber, NULL);
   // Do not delete birth.  We don't own it.
   Births* birth = ThreadData::TallyABirthIfActive(location);
   EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
 
-  // TimeTicks initializers ar ein microseconds.  Durations are calculated in
-  // milliseconds, so we need to use 1000x.
-  const base::TimeTicks time_posted = base::TimeTicks() +
-      base::TimeDelta::FromMilliseconds(1);
-  const base::TimeTicks delayed_start_time = base::TimeTicks();
-  const base::TimeTicks start_of_run = base::TimeTicks() +
-      base::TimeDelta::FromMilliseconds(5);
-  const base::TimeTicks end_of_run = base::TimeTicks() +
-      base::TimeDelta::FromMilliseconds(7);
-  ThreadData::TallyADeathIfActive(birth, time_posted, delayed_start_time,
-                                  start_of_run, end_of_run);
-
-  birth = ThreadData::TallyABirthIfActive(location);
-  ThreadData::TallyADeathIfActive(birth, time_posted, delayed_start_time,
-                                  start_of_run, end_of_run);
-
-  int process_type = 7;
-  scoped_ptr<base::Value> value(ThreadData::ToValue(process_type));
+
+  const base::TimeTicks kTimePosted = base::TimeTicks()
+      + base::TimeDelta::FromMilliseconds(1);
+  const base::TimeTicks kDelayedStartTime = base::TimeTicks();
+  // TrackingInfo will call TallyABirth() during construction.
+  MessageLoop::TrackingInfo pending_task(location, kDelayedStartTime);
+  pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
+
+  const TrackedTime kStartOfRun = TrackedTime() +
+      Duration::FromMilliseconds(5);
+  const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7);
+  ThreadData::TallyRunOnNamedThreadIfTracking(pending_task,
+      kStartOfRun, kEndOfRun);
+
+  // TrackingInfo will call TallyABirth() during construction.
+  MessageLoop::TrackingInfo pending_task2(location, kDelayedStartTime);
+  pending_task2.time_posted = kTimePosted;  // Overwrite implied Now().
+
+  ThreadData::TallyRunOnNamedThreadIfTracking(pending_task2,
+      kStartOfRun, kEndOfRun);
+
+  scoped_ptr<base::Value> value(ThreadData::ToValue());
   std::string json;
   base::JSONWriter::Write(value.get(), false, &json);
   std::string one_line_result = "{"
@@ -331,44 +378,43 @@ TEST_F(TrackedObjectsTest, TwoLives) {
             "\"line_number\":222"
           "}"
         "}"
-      "],"
-      "\"process\":7"
+      "]"
     "}";
   EXPECT_EQ(json, one_line_result);
 }
 
 TEST_F(TrackedObjectsTest, DifferentLives) {
-  if (!ThreadData::StartTracking(true))
+  if (!ThreadData::InitializeAndSetTrackingStatus(true))
     return;
 
   // Use a well named thread.
   ThreadData::InitializeThreadContext("SomeFileThreadName");
-  int fake_line_number = 567;
+  const int kFakeLineNumber = 567;
   const char* kFile = "AnotherFileName";
   const char* kFunction = "DifferentLives";
-  Location location(kFunction, kFile, fake_line_number, NULL);
-  // Do not delete birth.  We don't own it.
-  Births* birth = ThreadData::TallyABirthIfActive(location);
-  EXPECT_NE(birth, reinterpret_cast<Births*>(NULL));
+  Location location(kFunction, kFile, kFakeLineNumber, NULL);
+
+  const base::TimeTicks kTimePosted = base::TimeTicks()
+      + base::TimeDelta::FromMilliseconds(1);
+  const base::TimeTicks kDelayedStartTime = base::TimeTicks();
+  // TrackingInfo will call TallyABirth() during construction.
+  MessageLoop::TrackingInfo pending_task(location, kDelayedStartTime);
+  pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
+
+  const TrackedTime kStartOfRun = TrackedTime() +
+      Duration::FromMilliseconds(5);
+  const TrackedTime kEndOfRun = TrackedTime() + Duration::FromMilliseconds(7);
+  ThreadData::TallyRunOnNamedThreadIfTracking(pending_task,
+      kStartOfRun, kEndOfRun);
+
+  const int kSecondFakeLineNumber = 999;
+  Location second_location(kFunction, kFile, kSecondFakeLineNumber, NULL);
+
+  // TrackingInfo will call TallyABirth() during construction.
+  MessageLoop::TrackingInfo pending_task2(second_location, kDelayedStartTime);
+  pending_task2.time_posted = kTimePosted;  // Overwrite implied Now().
 
-  // TimeTicks initializers ar ein microseconds.  Durations are calculated in
-  // milliseconds, so we need to use 1000x.
-  const base::TimeTicks time_posted = base::TimeTicks() +
-      base::TimeDelta::FromMilliseconds(1);
-  const base::TimeTicks delayed_start_time = base::TimeTicks();
-  const base::TimeTicks start_of_run = base::TimeTicks() +
-      base::TimeDelta::FromMilliseconds(5);
-  const base::TimeTicks end_of_run = base::TimeTicks() +
-      base::TimeDelta::FromMilliseconds(7);
-  ThreadData::TallyADeathIfActive(birth, time_posted, delayed_start_time,
-                                  start_of_run, end_of_run);
-
-  int second_fake_line_number = 999;
-  Location second_location(kFunction, kFile, second_fake_line_number, NULL);
-  birth = ThreadData::TallyABirthIfActive(second_location);
-
-  int process_type = 2;
-  scoped_ptr<base::Value> value(ThreadData::ToValue(process_type));
+  scoped_ptr<base::Value> value(ThreadData::ToValue());
   std::string json;
   base::JSONWriter::Write(value.get(), false, &json);
   std::string one_line_result = "{"
@@ -401,8 +447,7 @@ TEST_F(TrackedObjectsTest, DifferentLives) {
             "\"line_number\":999"
           "}"
         "}"
-      "],"
-    "\"process\":2"
+      "]"
     "}";
   EXPECT_EQ(json, one_line_result);
 }