Add trace code to track all posted tasks in message_loop.

base/tracked.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 "build/build_config.h"
 
 #if defined(COMPILER_MSVC)
 // MSDN says to #include <intrin.h>, but that breaks the VS2005 build.
 extern "C" {
 void* _ReturnAddress();
 }
 #endif
 
 #include "base/tracked.h"
 
+#include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/tracked_objects.h"
 
 using base::TimeTicks;
 
 namespace tracked_objects {
 
 //------------------------------------------------------------------------------
 
-Location::Location(const char* function_name,
-                   const char* file_name,
-                   int line_number,
+Location::Location(const char* file_line,
+                   const char* function_name,
                    const void* program_counter)
-    : function_name_(function_name),
-      file_name_(file_name),
-      line_number_(line_number),
+    : file_line_(file_line),
+      function_name_(function_name),
       program_counter_(program_counter) {
 }
 
 Location::Location()
-    : function_name_("Unknown"),
-      file_name_("Unknown"),
-      line_number_(-1),
+    : file_line_("Unknown:-1"),
+      function_name_("Unknown"),
       program_counter_(NULL) {
 }
 
+const base::StringPiece Location::file_name() const {
+  base::StringPiece file_line(file_line_);
+  return file_line.substr(0, file_line.find_last_of(':'));
+}
+
+int Location::line_number() const {
+  base::StringPiece file_line(file_line_);
+  base::StringPiece::size_type colon1 = file_line.find_last_of(':');
+  int line_num = 0;
+  base::StringToInt(file_line.substr(colon1).as_string(), &line_num);
+  return line_num;
+}
+
+const base::StringPiece Location::function_name() const {
+  return base::StringPiece(function_name_);

[joth, 2011/09/15 10:38:09]

nit: is there any point returning this as a string piece when the caller just
wants to call .data() on it? The implicit strlen() call here is then wasted
effort, and the caller has to make an assumption that data() will be null
terminated. (c.f. it's easy for the caller to promote char* to StringPiece if
they need to).

[jbates, 2011/09/15 16:48:33]

I went back and forth on this one -- I was on the fence because of the lack of
perf-critical use cases, but may as well change to const char*.

+}
+
 void Location::Write(bool display_filename, bool display_function_name,
                      std::string* output) const {
   base::StringAppendF(output, "%s[%d] ",
-      display_filename ? file_name_ : "line",
-      line_number_);
+      display_filename ? file_name().as_string().c_str() : "line",
+      line_number());
 
   if (display_function_name) {
     WriteFunctionName(output);
     output->push_back(' ');
   }
 }
 
 void Location::WriteFunctionName(std::string* output) const {
   // Translate "<" to "&lt;" for HTML safety.
   // TODO(jar): Support ASCII or html for logging in ASCII.
@@ skipping 32 matching lines @@
 #if !defined(TRACK_ALL_TASK_OBJECTS)
 
 Tracked::Tracked() : birth_program_counter_(NULL) {}
 Tracked::~Tracked() {}
 
 void Tracked::SetBirthPlace(const Location& from_here) {
   birth_program_counter_ = from_here.program_counter();
 }
 
 const Location Tracked::GetBirthPlace() const {
-  static Location kNone("NoFunctionName", "NeedToSetBirthPlace", -1, NULL);
+  static Location kNone("NeedToSetBirthPlace:-1", "NoFunctionName", NULL);
   return kNone;
 }
 bool Tracked::MissingBirthPlace() const { return false; }
 void Tracked::ResetBirthTime() {}
 
 #else
 
 Tracked::Tracked()
     : tracked_births_(NULL),
       tracked_birth_time_(TimeTicks::Now()) {
@@ skipping 13 matching lines @@
     tracked_births_->ForgetBirth();
   ThreadData* current_thread_data = ThreadData::current();
   if (!current_thread_data)
     return;  // Shutdown started, and this thread wasn't registered.
   tracked_births_ = current_thread_data->TallyABirth(from_here);
 
   birth_program_counter_ = from_here.program_counter();
 }
 
 const Location Tracked::GetBirthPlace() const {
-  static Location kNone("UnknownFunctionName", "UnknownFile", -1, NULL);
+  static Location kNone;
   return tracked_births_ ? tracked_births_->location() : kNone;
 }
 
 void Tracked::ResetBirthTime() {
   tracked_birth_time_ = TimeTicks::Now();
 }
 
 bool Tracked::MissingBirthPlace() const {
-  return  !tracked_births_ || tracked_births_->location().line_number() == -1;
+  return  !tracked_births_ ||
+      tracked_births_->location().program_counter() == NULL;
 }
 
 #endif  // !defined(TRACK_ALL_TASK_OBJECTS)
 
 }  // namespace tracked_objects