Tag all tracked objects, including Tasks, with the program counter at the site of FROM_HERE.

base/message_loop.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/message_loop.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/debug/alias.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_pump_default.h"
 #include "base/metrics/histogram.h"
 #include "base/scoped_ptr.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/thread_local.h"
 #include "base/time.h"
 #include "base/tracked_objects.h"
 
@@ skipping 70 matching lines @@
   // if this class should leak the Task on destruction.  This is important
   // at MessageLoop shutdown since not all tasks can be safely deleted without
   // running.  See MessageLoop::DeletePendingTasks() for the exact behavior
   // of when a Task should be deleted. It is subtle.
   TaskClosureAdapter(Task* task, bool* should_leak_task)
       : task_(task),
         should_leak_task_(should_leak_task) {
   }
 
   void Run() {
+    // Before running the task, store the program counter where it was posted
+    // and deliberately alias it to ensure it is on the stack if the task
+    // crashes. Be careful not to assume that the variable itself will have the
+    // expected value when displayed by the optimizer in an optimized build.
+    // Look at a memory dump of the stack.
+    void* program_counter = task_->get_birth_program_counter();
+    base::debug::Alias(&program_counter);
+
     task_->Run();
     delete task_;
     task_ = NULL;
   }
 
  private:
   friend class base::RefCounted<TaskClosureAdapter>;
 
   ~TaskClosureAdapter() {
     if (!*should_leak_task_) {
@@ skipping 148 matching lines @@
 }
 
 void MessageLoop::RemoveDestructionObserver(
     DestructionObserver* destruction_observer) {
   DCHECK_EQ(this, current());
   destruction_observers_.RemoveObserver(destruction_observer);
 }
 
 void MessageLoop::PostTask(
     const tracked_objects::Location& from_here, Task* task) {
   CHECK(task);

[jar (doing other things), 2011/05/18 01:32:34]

These checks are probably not needed, now that you are about to deref the
instance in a method call (and presumably write to a slot close to the start of
the instance).

[apatrick_chromium, 2011/05/18 21:09:47]

SetBirthPlace calls are gone so the CHECK is not redundant now.

+  task->SetBirthPlace(from_here);
   PendingTask pending_task(
       base::Bind(&TaskClosureAdapter::Run,
                  new TaskClosureAdapter(task, &should_leak_tasks_)),
       from_here,
       CalculateDelayedRuntime(0), true);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostDelayedTask(
     const tracked_objects::Location& from_here, Task* task, int64 delay_ms) {
   CHECK(task);
+  task->SetBirthPlace(from_here);
   PendingTask pending_task(
       base::Bind(&TaskClosureAdapter::Run,
                  new TaskClosureAdapter(task, &should_leak_tasks_)),
       from_here,
       CalculateDelayedRuntime(delay_ms), true);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostNonNestableTask(
     const tracked_objects::Location& from_here, Task* task) {
   CHECK(task);
+  task->SetBirthPlace(from_here);
   PendingTask pending_task(
       base::Bind(&TaskClosureAdapter::Run,
                  new TaskClosureAdapter(task, &should_leak_tasks_)),
       from_here,
       CalculateDelayedRuntime(0), false);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostNonNestableDelayedTask(
     const tracked_objects::Location& from_here, Task* task, int64 delay_ms) {
   CHECK(task);
+  task->SetBirthPlace(from_here);
   PendingTask pending_task(
       base::Bind(&TaskClosureAdapter::Run,
                  new TaskClosureAdapter(task, &should_leak_tasks_)),
       from_here,
       CalculateDelayedRuntime(delay_ms), false);
   AddToIncomingQueue(&pending_task);
 }
 
 void MessageLoop::PostTask(
     const tracked_objects::Location& from_here, const base::Closure& task) {
@@ skipping 447 matching lines @@
 MessageLoop::PendingTask::PendingTask(
     const base::Closure& task,
     const tracked_objects::Location& posted_from,
     TimeTicks delayed_run_time,
     bool nestable)
     : task(task),
       time_posted(TimeTicks::Now()),
       delayed_run_time(delayed_run_time),
       sequence_num(0),
       nestable(nestable) {
-#if defined(TRACK_ALL_TASK_OBJECTS)

[apatrick_chromium, 2011/05/17 22:48:04]

Removing this is wrong but what it does overlaps with Tracked::SetBirthPlace.

[awong, 2011/05/17 23:54:01]

Corrently...we were trying to make it so Task doesn't inherit from Tracked. The
idea was to try and keep the Births in the PendingTask struct

If you remove all these task->SetBirthPlace() calls and return to having this
ifdef, I think you can find the needed Location higher up in the callstack in
the PendingTask struct for the task being Run().

[awong, 2011/05/17 23:54:55]

Corrently -> Correct.

One of these days I will learn to make less tipos. I sware.

[jar (doing other things), 2011/05/18 01:32:34]

It is similar to, but is not replaced by, what you injected with the 4
SetBirthPlace() calls above (example: new line 315).

It is OK to add the non-debugging code above, but it seems incorrect to remove
this code.  This code drives the task-counting system, which provides stats seen
in about:tasks.  I suspect those stats would be lost with this removal.

The replacement code provides some complex data (execution address) that can
plausibly be used to find the source of the task that was run.  (This decoding
is not even trivial to do in a debugger, I think).

That is only a small part of the functionality provided here.

[apatrick_chromium, 2011/05/18 21:09:47]

I think I see how this works now. This code block of code is back.

-  if (tracked_objects::ThreadData::IsActive()) {
-    tracked_objects::ThreadData* current_thread_data =
-        tracked_objects::ThreadData::current();
-    if (current_thread_data) {
-      post_births = current_thread_data->TallyABirth(posted_from);
-    } else {
-      // Shutdown started, and this thread wasn't registered.
-      post_births = NULL;
-    }
-  }
-#endif  // defined(TRACK_ALL_TASK_OBJECTS)
 }
 
 MessageLoop::PendingTask::~PendingTask() {
 }
 
 bool MessageLoop::PendingTask::operator<(const PendingTask& other) const {
   // Since the top of a priority queue is defined as the "greatest" element, we
   // need to invert the comparison here.  We want the smaller time to be at the
   // top of the heap.
 
@@ skipping 61 matching lines @@
                                            Watcher *delegate) {
   return pump_libevent()->WatchFileDescriptor(
       fd,
       persistent,
       static_cast<base::MessagePumpLibevent::Mode>(mode),
       controller,
       delegate);
 }
 
 #endif