Add queued_time_ms trace for events in message loop

base/location.cc

 // Copyright (c) 2012 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/location.h"
+#include "base/debug/trace_event.h"
+#include "base/json/string_escape.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
 #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/location.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/strings/stringprintf.h"
+namespace {
+
+class LocationConvertableToTraceFormat
+    : public base::debug::ConvertableToTraceFormat {
+ public:
+  LocationConvertableToTraceFormat(const char* function_name,
+                                   const char* file_name)
+      : function_name_(function_name),
+        file_name_(file_name) {
+  }
+
+  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {

[jar (doing other things), 2013/07/08 17:08:33]

When/how often does this get called? Is it only at display time?

This probably going to be expensive.

[Xianzhu, 2013/07/08 18:51:39]

It's only called at display (or save) time, once per event, when TraceLog
converts each event into JSON. It costs almost the same as what EventLog does
for other trace values (or a bit more if conversion to ConvertableToTraceFormat
and the virtual call are considered).

+    out->append("\"");
+    base::JsonDoubleQuote(function_name_, false, out);
+    out->append("@");
+    base::JsonDoubleQuote(file_name_, false, out);
+    out->append("\"");
+  }
+
+ private:
+  const char* function_name_;
+  const char* file_name_;
+};
+
+}  // namespace
 
 namespace tracked_objects {
 
 Location::Location(const char* function_name,
                    const char* file_name,
                    int line_number,
                    const void* program_counter)
     : function_name_(function_name),
       file_name_(file_name),
       line_number_(line_number),
       program_counter_(program_counter) {
 }
 
 Location::Location()
     : function_name_("Unknown"),
       file_name_("Unknown"),
       line_number_(-1),
       program_counter_(NULL) {
 }
 
 std::string Location::ToString() const {
   return std::string(function_name_) + "@" + file_name_ + ":" +
       base::IntToString(line_number_);
 }
 
+scoped_ptr<base::debug::ConvertableToTraceFormat>
+    Location::ToTraceFormat() const {
+  return scoped_ptr<base::debug::ConvertableToTraceFormat>(
+      new LocationConvertableToTraceFormat(function_name_, file_name_));
+}
+
 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_);
 
   if (display_function_name) {
     WriteFunctionName(output);
     output->push_back(' ');
   }
@@ skipping 41 matching lines @@
 #if defined(COMPILER_MSVC)
   return _ReturnAddress();
 #elif defined(COMPILER_GCC)
   return __builtin_extract_return_addr(__builtin_return_address(0));
 #endif  // COMPILER_GCC
 
   return NULL;
 }
 
 }  // namespace tracked_objects